生产者消费者模型(Producer-Consumer Model)是计算机科学中一个经典的并发编程模型,用于解决多线程/多进程环境下的协作问题。
基本概念
生产者:负责生成数据或任务的实体
消费者:负责处理数据或执行任务的实体
缓冲区:生产者与消费者之间共享的数据存储区域
模型特点
生产者与消费者以不同的速度运行
两者通过共享的缓冲区进行通信
缓冲区有大小限制,可能满或空
需要解决的问题
同步问题:
当缓冲区满时,生产者需要等待
当缓冲区空时,消费者需要等待
互斥问题:
对缓冲区的访问必须是互斥的,防止数据竞争
常见实现方式
使用信号量(Semaphore):空缓冲区信号量满缓冲区信号量互斥信号量
使用条件变量(Condition Variable)和互斥锁(Mutex)
使用阻塞队列(高级语言中常用)
本篇我们使用互斥锁和阻塞队列来解决这个问题
在多线程的锁中我们首先要避免的就是死锁这个问题,在 Java 中,Lock 接口及其实现类(如 ReentrantLock)是在 JDK 5(Java 5) 引入的,属于java.util.concurrent.locks 包的一部分。我们这里使用Java的synchronized实现
首先来分析问题,我们可以抽象的将生产者消费者问题想象为,厨师和顾客的问题:
顾客:
- 判断桌子上是否有食物
- 如果没有就等待
- 如果有就直接吃掉
- 吃完食物之后,通知厨师继续做食物
厨师:
- 判断桌子上是否有食物
- 如果桌子上有食物的话就等待
- 如果桌子上没有食物的话就制作食物
- 将食物放置在桌子上
- 唤醒等待的顾客开始吃
分析完毕,首先我们应该先新建三个类分别为:Cook(厨师类),Customer(顾客类),Desk(桌子类)
初始化桌子:
- 初始化桌子上食物的标志,
0为无食物,1为有食物
- 初始化顾客的上限,例如顾客最多吃10份食物
package Thread.Producer_Consumer;public class Desk {public static int FoodFlag=0;//食物当前的状态表示当前桌子上是否有食物public static int count=10;//消费者最多可以吃10个食物public static Object lock=new Object();////创建一个锁对象,用于生产者和消费者线程间的同步
}//由于是所有线程共同的变量所以我们使用static关键字修饰
接下来开始完成顾客线程
package Thread.Producer_Consumer;public class Customer extends Thread{//消费者线程@Overridepublic void run() {while( true){synchronized(Desk.lock){// 检查是否达到食物上限(count=0表示不能再吃)if(Desk.count==0){break;}else {// 检查桌子上是否有食物(FoodFlag=1表示有食物)if (Desk.FoodFlag == 1) {System.out.println("顾客吃掉食物");Desk.FoodFlag = 0;//表示没有食物Desk.count--;//剩余可吃食物数量减1System.out.println("顾客还可以吃"+Desk.count);Desk.lock.notifyAll();//唤醒lock锁中所有等待的线程} else {//桌上没有食物,则等待try {Desk.lock.wait();//释放锁,并进入等待状态} catch (InterruptedException e) {throw new RuntimeException(e);}}}}}System.out.println("顾客吃饱了,结束消费!");}
}
厨师线程
package Thread.Producer_Consumer;public class Cook extends Thread{@Overridepublic void run() {while (true) {synchronized (Desk.lock){//如果消费者可以吃的食物的数量已经达到最大,那么则直接退出if (Desk.count==0) {break;}else{//如果桌子有食物,等待消费者进程if(Desk.FoodFlag==1){try {Desk.lock.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}else{//如果桌子没有食物System.out.println("生产者正在生产食物...");//设置桌子有食物Desk.FoodFlag=1;//唤醒消费者线程Desk.lock.notifyAll();}}}}}
}
最后创建一个测试类
package Thread.Producer_Consumer;public class Test {public static void main(String[] args) {Desk desk=new Desk();Customer f1=new Customer();Cook c1=new Cook();f1.setName("消费者1");c1.setName("生产者1");f1.start();c1.start();}
}
下来我们使用阻塞队列来实现一下:
桌子类:
package Thread.Producer_Consumer_2;public class Desk {public static int count=10;//消费者最多可以吃10个食物public static int Food_max=10;
}
厨师类:
package Thread.Producer_Consumer_2;import java.util.concurrent.ArrayBlockingQueue;public class Cook extends Thread{ArrayBlockingQueue<String> queue;public Cook(ArrayBlockingQueue<String> queue){this.queue=queue;}//构造方法,创建一个阻塞队列@Overridepublic void run() {//厨师不断将食物放进队列中while(true){if(Desk.Food_max<=0){break;}else{try {queue.put("食物");System.out.println("厨师放了一个食物");Desk.Food_max--;} catch (InterruptedException e) {throw new RuntimeException(e);}}}}
}
顾客类:
package Thread.Producer_Consumer_2;import Thread.Producer_Consumer.Desk;import java.util.concurrent.ArrayBlockingQueue;public class Customer extends Thread{//消费者线程ArrayBlockingQueue<String> queue;public Customer(ArrayBlockingQueue<String> queue){this.queue=queue;}@Overridepublic void run() {while( true){if(Desk.count==0){System.out.println("顾客吃到上限了");break;}else{try {queue.take();System.out.println("消费者吃掉了一个食物");Desk.count--;} catch (InterruptedException e) {throw new RuntimeException(e);}}}}
}
测试类:
package Thread.Producer_Consumer_2;import Thread.Producer_Consumer.Desk;import java.util.concurrent.ArrayBlockingQueue;public class Test {public static void main(String[] args) {ArrayBlockingQueue<String> list=new ArrayBlockingQueue<>(5);//创建一个阻塞队列Customer f1=new Customer(list);Cook c1=new Cook(list);f1.setName("消费者1");c1.setName("生产者1");f1.start();c1.start();}
}
阻塞队列总结:
在创建阻塞队列的时候,需要创建实现类的对象,我们可以通过查看源码的形式来看一下
ArrayBlockingQueue实现了BlockingQueue这个接口
BlockingQueue又继承于Queue
Queue又继承于Collection
Collection又继承于Iterable,由此我们也就可以得出,阻塞队列是可以通过for_each循环遍历的
回归主题,在ArrayBlockingQueue中,有一个带参的构造方法,由此来创建阻塞队列,capacity代表阻塞队列的容量(不要忘记了泛型代表了阻塞队列的参数为哪种类型)
同时,LinkBlockingQueue也实现了BlockingQueue这个接口
由此可以得出一个图:
由于put()和take()方法都是自带锁的,所以我们并不用手动设置锁,同时,由于我们代码中的输出语句在锁的外面
这导致了输出时偶尔并不能按照我们的想法进行输出,但是执行时一定是正确的