JUC学习笔记 -- (8) 多线程并发之生产者消费者模式的两种实现

快来打我* 2022-05-12 14:18 66阅读 0赞

生产者消费者模式是并发、多线程编程中经典的设计模式，生产者和消费者通过分离的执行工作解耦，简化了开发模式，生产者和消费者可以以不同的速度生产和消费数据。

真实世界中的生产者消费者模式

生产者和消费者模式在生活当中随处可见，它描述的是协调与协作的关系。比如一个人正在准备食物（生产者），而另一个人正在吃（消费者），他们使用一个共用的桌子用于放置盘子和取走盘子，生产者准备食物，如果桌子上已经满了就等待，消费者（那个吃的）等待如果桌子空了的话。这里桌子就是一个共享的对象。

我们看这样一个例子：

生产者：  往一个公共的盒子里面放产品

消费者：从公共的盒子里面取产品

盒子：盒子的容量不能超过5

下面我们用两者方法分别实现这样一个场景。

方法一：   wait()  和   notify()   通信方法实现

看盒子代码

class Box{
    	private int product;
    
    	public synchronized void addProduct(){
    		while(product>=5){
    			try {
    				this.wait();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		product++;
    		System.out.println(Thread.currentThread().getName()+"生产了第:"+product+"个产品!");
    		this.notifyAll();
    
    	}
    
    	public synchronized void consumeProduct(){
    		while(product<=0){
    			try {
    				this.wait();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		System.out.println(Thread.currentThread().getName()+"消费了第:"+product+"个产品!");
    		product--;
    		this.notifyAll();
    	}
    }

生产者代码（生产十次）：

class Producer implements Runnable{
    
    	private Box box;
    
    
    	public Producer(Box box) {
    		this.box = box;
    	}
    	@Override
    	public void run() {
    		for(int i=0;i<10;i++){
    			try {
    				Thread.currentThread().sleep(200);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			box.addProduct();
    		}
    	}
    }

消费者代码（同样十次）：

class Consumer implements Runnable{
    
    	private Box box ;
    
    
    	public Consumer(Box box) {
    		this.box = box;
    	}
    	@Override
    	public void run() {
    		for(int i=0;i<10;i++){
    			try {
    				Thread.currentThread().sleep(200);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			box.consumeProduct();
    		}
    	}
    }

测试代码：

public class TestProducerAndConsumer {
    
    	public static void main(String[] args) {
    		Box box = new Box();
    		Producer Producer = new Producer(box);
    		Consumer consumer = new Consumer(box);
    
    		Thread t1 = new Thread(Producer,"生产者");
    		Thread t2 = new Thread(consumer,"消费者");
    
    		t1.start();
    		t2.start();
    	}
    }

输出如下：

生产者生产了第:1个产品!
    消费者消费了第:1个产品!
    生产者生产了第:1个产品!
    消费者消费了第:1个产品!
    生产者生产了第:1个产品!
    消费者消费了第:1个产品!
    生产者生产了第:1个产品!
    消费者消费了第:1个产品!
    生产者生产了第:1个产品!
    消费者消费了第:1个产品!
    生产者生产了第:1个产品!
    消费者消费了第:1个产品!
    生产者生产了第:1个产品!
    消费者消费了第:1个产品!
    生产者生产了第:1个产品!
    消费者消费了第:1个产品!
    生产者生产了第:1个产品!
    消费者消费了第:1个产品!
    生产者生产了第:1个产品!
    消费者消费了第:1个产品!

--------------------

方法二：采用阻塞队列实现生产者消费者模式

阻塞队列实现生产者消费者模式超级简单，它提供开箱即用支持阻塞的方法put()和take()，开发者不需要写困惑的wait-nofity代码去实现通信。BlockingQueue 一个接口，Java5提供了不同的现实，如ArrayBlockingQueue和LinkedBlockingQueue，两者都是先进先出（FIFO）顺序。而ArrayLinkedQueue是自然有界的，LinkedBlockingQueue可选的边界。下面这是一个完整的生产者消费者代码例子，对比传统的wait、nofity代码，它更易于理解。

生产者：

class ProducerQueue  implements Runnable{
    
    	private final BlockingQueue proQueue;
    	
    	
    	public ProducerQueue(BlockingQueue proQueue) {
    		this.proQueue = proQueue;
    	}
    	@Override
    	public void run() {
    		for(int i=0;i<10;i++){
    			try {
    			System.out.println("生产者生产的产品:"+i);
    				proQueue.put(i);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }

消费者：

class ConsumerQueue  implements Runnable{
    
    	private final BlockingQueue conQueue;
    	
    	
    	public ConsumerQueue(BlockingQueue conQueue) {
    		this.conQueue = conQueue;
    	}
    	@Override
    	public void run() {
    		for(int i=0;i<10;i++){
    			try {
    				System.out.println("消费者消费的产品:"+conQueue.take());
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }

测试代码:

public class TestProducerAndConsumer2 {
    
    	public static void main(String[] args) {
    		BlockingQueue queue = new LinkedBlockingQueue(5);
    		Thread t1 = new Thread(new ProducerQueue(queue),"生产者");
    		Thread t2 = new Thread(new ConsumerQueue(queue),"消费者");
    		t1.start();
    		t2.start();
    	}
    }

这里使用LinkedBlockingDeque就是代替第一种方式里的Box

结果如下：

生产者生产的产品:0
    生产者生产的产品:1
    生产者生产的产品:2
    消费者消费的产品:0
    生产者生产的产品:3
    消费者消费的产品:1
    生产者生产的产品:4
    消费者消费的产品:2
    生产者生产的产品:5
    消费者消费的产品:3
    生产者生产的产品:6
    消费者消费的产品:4
    生产者生产的产品:7
    消费者消费的产品:5
    生产者生产的产品:8
    消费者消费的产品:6
    消费者消费的产品:7
    生产者生产的产品:9
    消费者消费的产品:8
    消费者消费的产品:9

生产者消费者模式的好处

它的确是一种实用的设计模式，常用于编写多线程或并发代码。下面是它的一些优点：

1.   它简化的开发，你可以独立地或并发的编写消费者和生产者，它仅仅只需知道共享对象是谁
2.  生产者不需要知道谁是消费者或者有多少消费者，对消费者来说也是一样
3.   生产者和消费者可以以不同的速度执行
4.   分离的消费者和生产者在功能上能写出更简洁、可读、易维护的代码