Java生产者消费者模式-优快云博客

本文链接：https://blog.youkuaiyun.com/yjc0403/article/details/84834721

Java多线程之通信

在并发编程中，我们需要处理两个关键问题：线程之间如何通信及线程之间如何同步。通信是指线程之间以何种机制来交换信息。在命令式编程中，线程之间的通信机制有两种：共享内存和消息传递。

java内存模型

线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。

从上图来看，线程A与线程B之间如要通信的话，必须要经历下面2个步骤：

首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。
然后，线程B到主内存中去读取线程A之前已更新过的共享变量。

另一种消息传递的方式

生产者、消费者模式

生产者：没有生产之前通知消费者等待，生产产品结束之后，马上通知消费者消费
消费者：没有消费之前通知生产者等待，消费产品结束之后，通知生产者继续生产产品以供消费

其中使用了缓冲区，需要考虑下面两点

从缓冲区取出产品和向缓冲区投放产品必须是互斥进行的。可以用关键段和互斥量来完成。
生产者要等待缓冲区为空，这样才可以投放产品，消费者要等待缓冲区不为空，这样才可以取出产品进行消费。并且由于有二个等待过程，所以要用二个事件或信号量来控制。

两种发放实现生产者、消费者模式

看看下面例子：

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

消费者：从公共的盒子里面取苹果

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

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

        public class PublicBox { 
           private int apple = 0;     
           public synchronized void increace() { 
               while (apple ==5) { 
                   try { 
                       wait(); 
                   } catch (InterruptedException e) { 
                       e.printStackTrace(); 
                   } 
                  
               } 
               apple++; 
               System. out .println("生成苹果成功！" );
               notify(); 
           }       
           public synchronized void decreace() { 
               while (apple ==0) { 
                   try { 
                       wait(); 
                   } catch (InterruptedException e) { 
                       e.printStackTrace(); 
                   } 
               } 
               apple--; 
              System. out.println( "消费苹果成功！" );
               notify(); 
           } 
          
           public static void main(String []args)
              {
                     PublicBox box= new PublicBox();
                     
                     Consumer con= new Consumer(box);
                     Producer pro= new Producer(box);
                     
                     Thread t1= new Thread(con);
                     Thread t2= new Thread(pro);
                     
                     t1.start();
                     t2.start();
                     
                     
              }
       }

多个生产者和多个消费者

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

public class Producer implements Runnable { 
    private PublicBox box; 
 
    public Producer(PublicBox box) { 
        this .box = box; 
    } 
 
    @Override 
    public void run() { 
       
        for( int i=0;i<10;i++)  
       {
               try {
                     System. out .println("pro  i:" +i);
                           Thread. sleep(30);
                     } catch (InterruptedException e) {
                            // TODO: handle exception
                           e.printStackTrace();
                     }
       
            box.increace(); 
       }
        
    } 
}

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

public class Consumer implements Runnable { 
    private PublicBox box; 
 
    public Consumer(PublicBox box) { 
        this .box = box; 
    } 
 
    @Override 
    public void run() { 
       
        for( int i=0;i<10;i++)
       {
             try {
                     System. out .println("Con: i " +i);
                           Thread. sleep(3000);                // 这里设置跟上面30不同是为了 盒子中的苹果能够增加，不会生产一个马上被消费  
                     } catch (InterruptedException e) {
                            // TODO: handle exception
                           e.printStackTrace();
                     }
       
            box.decreace(); 
        } 
 } 
}

结果

pro i:0

Con: i 0

生成苹果成功！

pro i:1

生成苹果成功！

pro i:2

生成苹果成功！

pro i:3

生成苹果成功！

pro i:4

生成苹果成功！

pro i:5

消费苹果成功！

Con: i 1

生成苹果成功！

pro i:6

消费苹果成功！

Con: i 2

生成苹果成功！

pro i:7

消费苹果成功！

生成苹果成功！

pro i:8

Con: i 3

消费苹果成功！

生成苹果成功！

pro i:9

Con: i 4

消费苹果成功！

生成苹果成功！

Con: i 5

消费苹果成功！

Con: i 6

消费苹果成功！

Con: i 7

消费苹果成功！

Con: i 8

消费苹果成功！

Con: i 9

消费苹果成功！

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

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

盒子代码

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class PublicBoxQueue {

       
        public static void main(String []args)
       {
               BlockingQueue publicBoxQueue= new LinkedBlockingQueue(5);   //定义了一个大小为5的盒子
              
              Thread pro= new Thread(new ProducerQueue(publicBoxQueue));
              Thread con= new Thread(new ConsumerQueue(publicBoxQueue));
              
              pro.start();
              con.start();
       }
       
}

生产者

package dsd;

import java.util.concurrent.BlockingQueue;

public class ProducerQueue implements Runnable {

        private final BlockingQueue proQueue;
       
        public ProducerQueue(BlockingQueue proQueue)
       {
               this .proQueue =proQueue;
       }

        @Override
        public void run() {
               // TODO Auto-generated method stub
              
               for (int i=0;i<10;i++)
              {
                      try {
                           System. out .println("生产者生产的苹果编号为 : " +i);  //放入十个苹果编号 为1到10
                            proQueue .put(i);
                           
                            /*Thread.sleep(3000);*/
                     } catch (InterruptedException  e) {
                            // TODO: handle exception
                           e.printStackTrace();
                     }
                     
              }
              
       }
       
       
}

消费者

package dsd;

import java.util.concurrent.BlockingQueue;

public class ConsumerQueue implements Runnable {

        private final BlockingQueue conQueue;
       
        public ConsumerQueue(BlockingQueue conQueue)
       {
               this .conQueue =conQueue;
       }

        @Override
        public void run() {
               // TODO Auto-generated method stub
               for (int i=0;i<10;i++)
              {
                      try {
                           System. out .println("消费者消费的苹果编号为 ：" +conQueue .take());
                           Thread. sleep(3000);  //在这里sleep是为了看的更加清楚些
                           
                     } catch (InterruptedException e) {
                            // TODO: handle exception
                           e.printStackTrace();
                     }
              }
       }
       
       
}

结果

生产者生产的苹果编号为 : 0

生产者生产的苹果编号为 : 1

消费者消费的苹果编号为：0

生产者生产的苹果编号为 : 2

生产者生产的苹果编号为 : 3

生产者生产的苹果编号为 : 4

生产者生产的苹果编号为 : 5

生产者生产的苹果编号为 : 6

生产者生产的苹果编号为 : 7

消费者消费的苹果编号为：1

消费者消费的苹果编号为：2

生产者生产的苹果编号为 : 8

消费者消费的苹果编号为：3

生产者生产的苹果编号为 : 9

消费者消费的苹果编号为：4

消费者消费的苹果编号为：5

消费者消费的苹果编号为：6

消费者消费的苹果编号为：7

消费者消费的苹果编号为：8

消费者消费的苹果编号为：9

生产者消费者模式优点

解耦：分开生产者和消费者的依赖，耦合度低。
支持并发：生产者和消费者是两个独立的并发体，他们通过缓冲区作为桥梁，生产者只需要往缓冲区里丢数据，就可以生产下一个数据，消费者只需要在缓冲区中取数据，这样两个并发体都不会因为出来速度而引起阻塞。
支持忙闲不均：如果生产者时快时慢，缓冲区的好处就好大，当生产者速度很快，任务就会在缓冲区缓存起来，让消费者依次去执行；当生产者速度比较慢，消费者可以从缓冲区中取任务，消费者不需要等到生产了任务才有工作，除非缓冲区为空。

应用场景