生产者/消费者问题的多种Java实现方式

太过爱你忘了你带给我的痛 2022-06-18 02:54 190阅读 0赞

生产者消费者问题是研究多线程程序时绕不开的经典问题之一，它描述是有一块缓冲区作为仓库，生产者可以将产品放入仓库，消费者则可以从仓库中取走产品。解决生产者/消费者问题的方法可分为两类：  
（1）采用某种机制保护生产者和消费者之间的同步；  
（2）在生产者和消费者之间建立一个管道。  
第一种方式有较高的效率，并且易于实现，代码的可控制性较好，属于常用的模式。第二种管道缓冲区不易控制，被传输数据对象不易于封装等，实用性不强。因此本文只介绍同步机制实现的生产者/消费者问题。  
同步问题核心在于：如何保证同一资源被多个线程并发访问时的完整性。常用的同步方法是采用信号或加锁机制，保证资源在任意时刻至多被一个线程访问。Java语言在多线程编程上实现了完全对象化，提供了对同步机制的良好支持。在Java中一共有四种方法支持同步，其中前三个是同步方法，一个是管道方法。  
（1）wait() / notify()方法（notifyAll()）  
（2）await() / signal()方法（signalAll()）  
（3）BlockingQueue阻塞队列方法  
（4）PipedInputStream / PipedOutputStream  
本文只介绍最常用的前两种，第四种暂不做讨论，有兴趣的读者可以自己去网上找答案。  
一、wait() / notify()方法  
wait() / nofity()方法是基类Object的两个方法，也就意味着所有Java类都会拥有这两个方法，这样，我们就可以为任何对象实现同步机制。  
wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。  
notify()方法：当生处产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，唤醒等待队列中的某个线程，同时放弃锁，使自己于等待状态，让该线程成为可运行状态。  
notityAll()方法：就是唤醒所有等待队列中的线程，去参加这个锁的竞争，至于运行哪个线程则由cpu根据线程优先级决定。建议使用notifyAll()；

import java.util.LinkedList;
    /** * 生产者消费者问题 * @author zhaojw_420 * */
    public class BoundedBuffer { 
    
          public static void main(String[] args) {
                //仓库对象
                Storge storge=new Storge();
    
                //生产者对象
                Producer p1=new Producer(storge);
                p1.setNum(10);
                Producer p2=new Producer(storge);
                p2.setNum(10);
                Producer p3=new Producer(storge);
                p3.setNum(10);
                Producer p4=new Producer(storge);
                p4.setNum(10);
                Producer p5=new Producer(storge);
                p5.setNum(10);
                Producer p6=new Producer(storge);
                p6.setNum(10);
                Producer p7=new Producer(storge);
                p7.setNum(10);
                //构建生产者对象线程
                Thread producer1=new Thread(p1);
                Thread producer2=new Thread(p2);
                Thread producer3=new Thread(p3);
                Thread producer4=new Thread(p4);
                Thread producer5=new Thread(p5);
                Thread producer6=new Thread(p6);
                Thread producer7=new Thread(p7);
    
                //消费者对象
                Consumer c1=new Consumer(storge);
                c1.setNum(50);
                Consumer c2=new Consumer(storge);
                c2.setNum(30);
                Consumer c3=new Consumer(storge);
                c3.setNum(20);
    
                //构建消费者对象线程
                Thread consumer1=new Thread(c1);
                Thread consumer2=new Thread(c2);
                Thread consumer3=new Thread(c3);
    
                //启动消费者线程
                consumer1.start();
                consumer2.start();
                consumer3.start();
    
                //启动生产者线程
                producer1.start();
                producer2.start();
                producer3.start();
                producer4.start();
                producer5.start();
                producer6.start();
                producer7.start();
          }
    }
    /** * 仓库类实现缓冲区 * @author zhaojw_420 * */
    class Storge{
          /** * 仓库最大存储量 */
          private final int MAX_SIZE=100;
          /** * 仓库存储的载体 */
          private LinkedList<Object> list=new LinkedList<Object>();
    
          public LinkedList<Object> getList() {
                return list;
          }
          public void setList(LinkedList<Object> list) {
                this.list = list;
          }
          public int getMAX_SIZE() {
                return MAX_SIZE;
          }
          /** * 仓库中存进num个产品 * @param num 存储产品个数 */
          public void produce(int num){
                //同步代码快
                synchronized(list){
                while((list.size()+num)>MAX_SIZE){
                      System.err.println(System.currentTimeMillis()+"，本次生产的产品数量："+num+"个，此时的库存量："+list.size()+"，暂时不能执行生产任务！");
    
                      try {
                            list.wait();//仓库已满，不能生产，此时生产线程处于阻塞状态
                      } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                      }
                }
                //仓库未满，可以生产，生产num个产品
                for (int i = 0; i < num; i++) {
                      list.add(i);
                }
    
                System.out.println(System.currentTimeMillis()+"，此次生产产品数量："+num+"个，现在库存量为："+list.size());
    
                list.notifyAll();//唤醒等待队列的线程
                }
          }
          /** * 消费num个产品 * @param num */
          public void consume(int num){
                //同步代码块
                synchronized(list){
                      //仓库数量不足，无法消费
                      while(list.size()<num){
                            System.err.println(System.currentTimeMillis()+"，本次消费的产品数量为："+num+"，库存量："+list.size()+"，暂时不能执行生产任务！");
                          try {
                                  list.wait();//消费条件不满足，消费线程处于阻塞状态
                            } catch (InterruptedException e) {
                                  // TODO Auto-generated catch block
                                  e.printStackTrace();
                            }     
                      }
    
                      //消费情况满足，消费num个产品
                      for (int i = 0; i < num; i++) {
                            list.remove();
                      }
    
                      System.out.println(System.currentTimeMillis()+"，本次消费产品数量："+num+"，现库存量为："+list.size());
    
                      list.notifyAll();//唤醒等待队列的线程
                }
          }
    }
    /** * 生产类，实现Runable接口 * @author zhaojw_420 * */
    class Producer implements Runnable{
          /** * 每次成产产品数量 */
          private int num;
    
          /** * 所放置的仓库 */
          private Storge storge;
          /** * 构造方法，设置仓库 * @param boundedBuffer */
          public Producer(Storge storge) {
                this.storge = storge;
          }
          @Override
          public void run() {
                // TODO Auto-generated method stub
                storge.produce(num);
          }
          public int getNum() {
                return num;
          }
          public void setNum(int num) {
                this.num = num;
          }
          public Storge getStorge() {
                return storge;
          }
          public void setStorge(Storge storge) {
                this.storge = storge;
          }
    }
    /** * 消费者类，实现Runable接口 * @author zhaojw_420 * */
    class Consumer implements Runnable{
          /** * 每次消费的产品数量 */
          private int num;
          /** * 存储仓库 */
          private Storge storge;
          /** * 构造函数，设置仓库 * @param boundedBuffer */
          public Consumer(Storge storge) {
                this.storge = storge;
          }
          @Override
          public void run() {
                storge.consume(num);
          }
          public int getNum() {
                return num;
          }
          public void setNum(int num) {
                this.num = num;
          }
          public Storge getStorge() {
                return storge;
          }
          public void setStorge(Storge storge) {
                this.storge = storge;
          }
    }

![这里写图片描述][SouthEast]

二、await()方法/signal()方法  
在JDK5.0之后，Java提供了更加健壮的线程处理机制，包括同步、锁定、线程池等，它们可以实现更细粒度的线程控制。await()和signal()就是其中用来做同步的两种方法，它们的功能基本上和wait() / nofity()相同，完全可以取代它们，但是它们和新引入的锁定机制Lock直接挂钩，具有更大的灵活性。通过在Lock对象上调用newCondition()方法，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全。  
例如：

/** * 仓库类实现缓冲区 * @author zhaojw_420 * */
    class StorgeAwait{
          /** * 仓库最大存储量 */
          private final int MAX_SIZE=100;
          /** * 仓库存储的载体 */
          private LinkedList<Object> list=new LinkedList<Object>();
    
          /** * 可重入锁 */
          private final Lock lock=new ReentrantLock();
    
          /** * 仓库满条件 */
          private final Condition full=lock.newCondition();
    
          /** * 仓库空条件 */
          private final Condition empty=lock.newCondition();
    
          public LinkedList<Object> getList() {
                return list;
          }
          public void setList(LinkedList<Object> list) {
                this.list = list;
          }
          public int getMAX_SIZE() {
                return MAX_SIZE;
          }
          /** * 仓库中存进num个产品 * @param num 存储产品个数 */
          public void produce(int num){
                //获得锁
                lock.lock();
    
                while((list.size()+num)>MAX_SIZE){
                      System.err.println(System.currentTimeMillis()+"，本次生产的产品数量："+num+"个，此时的库存量："+list.size()+"，暂时不能执行生产任务！");
    
                      try {
                            full.await();//仓库已满，不能生产，此时生产线程处于阻塞状态
                      } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                      }
                }
                //仓库未满，可以生产，生产num个产品
                for (int i = 0; i < num; i++) {
                      list.add(i);
                }
    
                System.out.println(System.currentTimeMillis()+"，此次生产产品数量："+num+"个，现在库存量为："+list.size());
    
                full.signalAll();//唤醒等待队列的线程
                empty.signalAll();
    
                //释放锁
                lock.unlock();
    
          }
          /** * 消费num个产品 * @param num */
          public void consume(int num){
    
                   //获得锁
                   lock.lock();
    
                      //仓库数量不足，无法消费
                      while(list.size()<num){
                            System.err.println(System.currentTimeMillis()+"，本次消费的产品数量为："+num+"，库存量："+list.size()+"，暂时不能执行生产任务！");
                          try {
                                  empty.await();//消费条件不满足，消费线程处于阻塞状态
                            } catch (InterruptedException e) {
                                  // TODO Auto-generated catch block
                                  e.printStackTrace();
                            }     
                      }
    
                      //消费情况满足，消费num个产品
                      for (int i = 0; i < num; i++) {
                            list.remove();
                      }
    
                      System.out.println(System.currentTimeMillis()+"，本次消费产品数量："+num+"，现库存量为："+list.size());
    
                      empty.signalAll();      //唤醒等待队列的线程
                      full.signalAll();
    
                      lock.unlock();//释放锁
    
          }
    }

![这里写图片描述][SouthEast 1]

[SouthEast]: /images/20220618/4c7e141b27ab4906bf0e9cd4a63ba3ab.png
[SouthEast 1]: /images/20220618/332cad839a38470c8176fa7378a45df0.png