生产者与消费者问题

生产者与消费者问题

等待唤醒机制经典的案例就是***生产者与消费者***的问题。

举一个例子：生产包子与消费包子来描述等待唤醒机制如何有效的利用资源：

代码示例：

/*
 * 资源类：包子类
 *    设置包子的属性
 *      皮
 *      馅
 *      包子的状态  有 true 没有 false
 */
public class Baozi {
	// 皮
	String pi;
	// 馅
	String xian;
	// 包子的状态  有 true 没有 false,设置初始值为false，没有包子
	boolean flag = false;
	
}
// 包子铺
/*
 * 生产者(包子铺)：是一个线程类，继承Thread类
 * 	设置线程的任务：生产包子
 *   true：有包子
 *    包子铺调用wait方法进入等待状态
 *   false：没有包子
 *     增加一些难度：交替生产两种包子
 *     有两种状态：(i % 2 == 0)
 *    包子铺生产包子
 *    修改包子的状态为true
 *    唤醒吃货线程，让吃货去吃包子
 *    
 *  注意：
 *  	包子铺线程和吃货线程关系---->通信(互斥)
 *      必须使用同步技术保证两个线程只能有一个线程在执行
 *      锁对象必须保证唯一，可以使用包子对象作为锁对象
 *      包子铺线程和吃货线程的类需要把包子对象作为参数传递进来
 *         1.需要在成员的位置上创建一个包子变量
 *         2.使用带参构造，为这个包子变量赋值 	     
 */
public class Costs extends Thread{
	//1.需要在成员的位置上创建一个包子变量
	private Baozi baozi;
	
	//2.使用带参构造，为这个包子变量赋值 	
	public Costs(Baozi baozi) {
		this.baozi = baozi;
	}
	
	// 重写run方法
	@Override
	public void run() {
		// 设置线程任务：生产包子
		// 定义一个变量
		int count = 0;
		// 让包子铺一直生产包子
		while(true) {
			// 必须保证两个线程只能有一个线程在执行
			synchronized (baozi) {
				// 进行包子状态的判断
				if (baozi.flag) {
					//包子铺有包子，包子铺需要调用wait方法进入等待状态
					try {
						baozi.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				// 包子铺没有包子，被唤醒之后，包子铺生产包子
				// 增加一些难度：交替生产两种类型的包子
				if (count % 2 == 0) {
					//生产 三鲜馅的包子，皮是薄皮
					baozi.pi = "薄皮";
					baozi.xian= "三鲜馅";
				} else {
					// 生产  猪肉大葱馅 冰皮
					baozi.pi = "冰皮";
					baozi.xian = "猪肉大葱馅";
				}
				count++;
				System.out.println("包子铺正在生产：" + baozi.pi + baozi.xian + "包子");
				// 生产包子需要有一个过程：等待3秒钟
				try {
					Thread.sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// 包子铺生产好了包子
				// 修改包子的状态为true 有
				baozi.flag = true;
				// 唤醒吃货线程，让吃货线程去吃包子
				baozi.notify();
				System.out.println("包子铺已经生产好了：" + baozi.pi + baozi.xian + "包子，吃货可以开始吃了。。");
			}
		}
	}
}
/*
 * 消费者(吃货)类：是一个线程类  extends Thread
 *   设置线程的任务：吃包子
 *   对包子的状态进行判断
 *   true：有包子
 *      吃货吃包子
 *      吃货吃完包子
 *      修改包子的状态味false：没有包子
 *      吃货唤醒包子铺线程，生产包子
 *   false：没有包子
 *      吃货调用wait方法，进入到等待状态
 */
public class Foodie extends Thread{
	// 1. 需要在成员的位置上定义一个包子变量
	private Baozi baozi;
	
	//2.使用带参构造，为这个包子变量赋值
	public Foodie(Baozi baozi) {
		this.baozi = baozi;
	}
	
	//3. 重写run方法
	@Override
	public void run() {
		// 设置线程任务：吃包子
		// 使用死循环，让吃货一直吃包子
		while(true) {
			// 使用同步技术保证两个线程只有一个线程在执行
			synchronized (baozi) {
				// 对包子的状态进行判断
				if (baozi.flag == false) {
					// 让吃货线程进入到等待状态
					try {
						baozi.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				// 被唤醒后执行吃包子
				System.out.println("吃货正在吃：" + baozi.pi + baozi.xian + "包子");
				// 吃货吃完包子
				// 修改包子的状态为false 没有
				baozi.flag = false;
				// 吃货线程唤醒包子铺线程--->生产包子
				baozi.notify();
				System.out.println("吃货已经把" + baozi.pi + baozi.xian + "的包子");
				System.out.println("------------------------------------------");
			}
		}
	}
}
public class TestChihuoAndBaoziPuDemo {

	public static void main(String[] args) {
		// 创建包子对象
		Baozi baozi = new Baozi();
		// 创建包子铺线程对象
		new Costs(baozi).start();
		// 创建吃货线程对象
		new Foodie(baozi).start();
	}
	
}

线程测试的结果如下：

包子铺线程生产包子，吃货线程消费包子。当没有包子的时候(包子的状态为false)，吃货线程需要等待，包子铺线程生产包子（包子的状态为true），并通知吃货线程(解除吃货等待的状态)，因为已经有了包子，所以包子铺线程就需要进入到等待状态。
    接下来，吃货线程能否进一步执行则取决于锁的获取情况，如果吃货线程获取到锁，那么就执行吃包子的动作，包子吃完了(包子的状态为false)，需要通知包子铺线程(解除包子铺线程等待状态)，此时吃货线程就进入到等待状态。包子铺线程能否进一步执行则取决于锁的获取情况。