自定义线程 生产者消费者 join方法

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qwer1203355251/article/details/52938789

1.

/*
 * 1.自定义一个类实现Runnable接口
 * 2.实现Runnable接口的run方法，自定义线程的任务放在run方法中
 * 3.创建Runnable实现类对象
 * 4.创建Thread对象，并把Runnable的对象作为实参传递给，构造函数
 * 5.调用Thread的run方法开启一个进程
 * */
public class RunablePractice implements Runnable
{
	int num = 50;//不用static即可
	public void run() 
	{
		while(true)
		{
			synchronized ("锁") 
			{
				if(num>0)
				{
					System.out.println(Thread.currentThread().getName()+"卖出了第"+num--+"张票");
					try 
					{
						Thread.sleep(10);
					} 
					catch (InterruptedException e)
					{
						e.printStackTrace();
					}
				}
				else
				{
					System.out.println("卖完了");
					break;
				}
			}
		}
	}
	public static void main(String[] args) 
	{
		RunablePractice r = new RunablePractice();
		Thread t1 = new Thread(r,"窗口1");
		Thread t2 = new Thread(r,"窗口2");
		Thread t3 = new Thread(r,"窗口3");
		t1.start();
		t2.start();
		t3.start();
	}
}

运行结果：


窗口1卖出了第50张票
窗口3卖出了第49张票
窗口3卖出了第48张票
窗口2卖出了第47张票
窗口2卖出了第46张票
窗口3卖出了第45张票
窗口3卖出了第44张票
窗口1卖出了第43张票
窗口3卖出了第42张票
窗口2卖出了第41张票
窗口3卖出了第40张票
窗口3卖出了第39张票
窗口1卖出了第38张票
窗口1卖出了第37张票
窗口3卖出了第36张票
窗口3卖出了第35张票
窗口2卖出了第34张票
窗口2卖出了第33张票
窗口2卖出了第32张票
窗口3卖出了第31张票
窗口3卖出了第30张票
窗口3卖出了第29张票
窗口1卖出了第28张票
窗口3卖出了第27张票
窗口2卖出了第26张票
窗口2卖出了第25张票
窗口2卖出了第24张票
窗口2卖出了第23张票
窗口3卖出了第22张票
窗口3卖出了第21张票
窗口3卖出了第20张票
窗口1卖出了第19张票
窗口1卖出了第18张票
窗口1卖出了第17张票
窗口3卖出了第16张票
窗口3卖出了第15张票
窗口3卖出了第14张票
窗口3卖出了第13张票
窗口3卖出了第12张票
窗口2卖出了第11张票
窗口2卖出了第10张票
窗口2卖出了第9张票
窗口2卖出了第8张票
窗口2卖出了第7张票
窗口3卖出了第6张票
窗口1卖出了第5张票
窗口1卖出了第4张票
窗口1卖出了第3张票
窗口3卖出了第2张票
窗口2卖出了第1张票
卖完了
卖完了
卖完了
2.

import java.util.Random;


class Product 
{
	double price;
	String name;
	boolean flag = false;
	public Product(){}
	public Product(String name, double price)
	{
		this.name = name;
		this.price = price;
	}
}


//wait notify
//wait和notify是属于Object对象
//必须要在同步代码块或者是同步函数中才能使用
//必须由锁对象调用


class Producer implements Runnable
{
	Random random = new Random();
	int a;
	Product p;
	public Producer(Product p)
	{
		this.p = p;
	}
	public void run()
	{
		while(true)
		{
			synchronized(p) 
			{
				if(p.flag==false)
				{
					a = random.nextInt(2);
					if(a==0)
					{
						p.name = "苹果";
						p.price = 3.2;
					}
					else
					{
						p.name = "香蕉";
						p.price = 7.3;
					}
					p.flag = true;
					System.out.println("生产了一个"+p.name+"，价格为："+p.price+"....唤醒消费者....");	
					p.notify();
				}
				else
				{
					System.out.println("正在等待消费者");
					try 
					{
						p.wait();
					} 
					catch (InterruptedException e)
					{
						e.printStackTrace();
					}
				}
			}
		}
	}
}


class Consumer implements Runnable
{
	Product p;
	public Consumer(Product p)
	{
		this.p = p;
	}
	public void run() 
	{
		while(true)
		{
			synchronized(p)
			{
				if(p.flag==true)
				{
					System.out.println("消费者正在消费...");
					try 
					{
						Thread.sleep(1000);
					} 
					catch (InterruptedException e)
					{
						e.printStackTrace();
					}
					System.out.println("消费者消费了一个产品！！！....唤醒生产者.....");
					p.flag = false;
					p.notify();
				}
				else 
				{
					System.out.println("等待生产者");
					try {
						p.wait();
					} catch (InterruptedException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
				}
			}
		}
	}
}


public class ProducerConsumer
{
	public static void main(String[] args) 
	{
		Product t = new Product();
		Producer p = new Producer(t);
		Consumer c = new Consumer(t);
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(c);
 		t1.start();
 		t2.start();
	}
}

运行结果：


生产了一个香蕉，价格为：7.3....唤醒消费者....
正在等待消费者
消费者正在消费...
消费者消费了一个产品！！！....唤醒生产者.....
等待生产者
生产了一个香蕉，价格为：7.3....唤醒消费者....
正在等待消费者
消费者正在消费...
消费者消费了一个产品！！！....唤醒生产者.....
等待生产者
生产了一个苹果，价格为：3.2....唤醒消费者....
正在等待消费者
消费者正在消费...
消费者消费了一个产品！！！....唤醒生产者.....
等待生产者
生产了一个苹果，价格为：3.2....唤醒消费者....
正在等待消费者
消费者正在消费...
消费者消费了一个产品！！！....唤醒生产者.....
生产了一个苹果，价格为：3.2....唤醒消费者....
正在等待消费者
消费者正在消费...
消费者消费了一个产品！！！....唤醒生产者.....
生产了一个香蕉，价格为：7.3....唤醒消费者....
正在等待消费者
消费者正在消费...
消费者消费了一个产品！！！....唤醒生产者.....
生产了一个苹果，价格为：3.2....唤醒消费者....
正在等待消费者
消费者正在消费...
消费者消费了一个产品！！！....唤醒生产者.....
等待生产者
生产了一个苹果，价格为：3.2....唤醒消费者....
正在等待消费者
消费者正在消费...
消费者消费了一个产品！！！....唤醒生产者.....
生产了一个苹果，价格为：3.2....唤醒消费者....
正在等待消费者
消费者正在消费...
消费者消费了一个产品！！！....唤醒生产者.....
等待生产者
生产了一个苹果，价格为：3.2....唤醒消费者....
正在等待消费者
消费者正在消费...


3.守护线程

public class HouProcess extends Thread
{
	public HouProcess(String name)
	{
		super(name);
	}
	public void run() 
	{
		for(int i = 1;i<=100;i++)
		{
			System.out.println("更新包已经下载了"+i+"%");
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("更新包下载完成，等待安装");
	}
	public static void main(String[] args) 
	{
		HouProcess h = new HouProcess("后台进程");
		h.setDaemon(true);//让h线程成为守护线程
		System.out.println("是守护进程吗？ "+h.isDaemon());
		h.start();
		for(int i = 1;i<=100;i++)
		{
			System.out.println("main"+i);
		}
	}
}

是守护进程吗？ true
main1
main2
main3
main4
更新包已经下载了1%
main5
main6
main7
main8
main9
main10
main11
main12
main13
main14
main15
main16
main17
main18
main19
main20
main21
main22
main23
main24
main25
main26
main27
main28
main29
main30
main31
main32
main33
main34
main35
main36
main37
main38
main39
main40
main41
main42
main43
main44
main45
main46
main47
main48
main49
main50
main51
main52
main53
main54
main55
main56
main57
main58
main59
main60
main61
main62
main63
main64
main65
main66
main67
main68
main69
main70
main71
main72
main73
main74
main75
main76
main77
main78
main79
main80
main81
main82
main83
main84
main85
main86
main87
main88
main89
main90
main91
main92
main93
main94
main95
main96
main97
main98
main99
main100
4.

class Mom extends Thread
{
	public void run() {
		System.out.println("洗菜炒菜");
		System.out.println("没有酱油了....");
		System.out.println("叫儿子打酱油");
		Son s = new Son();
		s.start();
		try {
			s.join();//儿子加入线程,老妈暂停
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("继续炒菜");
		System.out.println("一起吃饭");
	}
}


class Son extends Thread 
{
	public void run() {
		System.out.println("儿子跑去买酱油...");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("买回来了");
	}
}


public class Join1 {
	public static void main(String[] args) {
		Mom m = new Mom();
		m.start();
	}
}

运行结果：


洗菜炒菜
没有酱油了....
叫儿子打酱油
儿子跑去买酱油...
买回来了
继续炒菜
一起吃饭