生产者消费者模式的使用分析

生产者消费者模式并不是GOF提出的23种设计模式之一，23种设计模式都是建立在面向对象的基础之上的，但其实面向过程的编程中也有很多高效的编程模式，生产者消费者模式便是其中之一，它是我们编程过程中最常用的一种设计模式。
生产者消费者模式是为了解决哪一类问题而产生的呢？在实际的软件开发过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。单单抽象出生产者和消费者，还够不上是生产者／消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据。

生产者消费者的关系如下图所示：
  

生产者消费者模式的原理描述：
（1）生产者仅仅在仓储未满时候生产，仓满则停止生产。
（2）消费者仅仅在仓储有产品时候才能消费，仓空则等待。
（3）当消费者发现仓储没产品可消费时候会通知生产者生产。
（4）生产者在生产出可消费产品时候，应该通知等待的消费者去消费。
下面通过一个例子描述下生产者消费者模式的使用。 
1、第一个文件ProductStorage.java

点击(此处)折叠或打开

1. /**
   
2.  * 库存商品管理类 
   
3.  */
   
4. public class ProductStorage {
   
5. 
   
6.     /**
   
7.      * 最大库存量
   
8.      */
   
9.     public static final int Maximum = 100;
   
10.     
    
11.     /**
    
12.      * 当前库存量
    
13.      */
    
14.     public static int Currentimum = 50;
    
15.     
    
16.     /**
    
17.      * 库存管理实例
    
18.      */
    
19.     private static ProductStorage instance;
    
20.     
    
21.     private ProductStorage(){}
    
22.     
    
23.     /**
    
24.      * 获取单例
    
25.      * @return
    
26.      */
    
27.     public static ProductStorage getInstance(){
    
28.         if(instance == null){
    
29.             instance = new ProductStorage();
    
30.         }
    
31.         return instance;
    
32.     }
    
33.     
    
34.     /**
    
35.      * 生产产品
    
36.      */
    
37.     public synchronized void product(){
    
38.         while(Currentimum >= Maximum/2){
    
39.             try {
    
40.                 wait();
    
41.             } catch (InterruptedException e) {
    
42.                 e.printStackTrace();
    
43.             }
    
44.         }
    
45.         Currentimum++;
    
46.         System.out.println("当前线程："+Thread.currentThread().getName() + "--生产者生产了一个商品，当前库存量："+ Currentimum);
    
47.         notifyAll();
    
48.     }
    
49.     
    
50.     /**
    
51.      * 消费产品
    
52.      */
    
53.     public synchronized void consume(){
    
54.         while(Currentimum <= 0){
    
55.             try {
    
56.                 wait();
    
57.             } catch (InterruptedException e) {
    
58.                 e.printStackTrace();
    
59.             }
    
60.         }
    
61.         Currentimum--;
    
62.         System.out.println("当前线程："+Thread.currentThread().getName() + "--消费者消费了一个商品，当前库存量："+ Currentimum);
    
63.         notifyAll();
    
64.     }
    
65. }

2、第二个文件Producter.java

点击(此处)折叠或打开

1. /**
   
2.  * 商品生产者模型
   
3.  */
   
4. public class Producter implements Runnable {
   
5.     
   
6.     @Override
   
7.     public void run(){
   
8.         while(true){
   
9.             try {
   
10.                 Thread.sleep(500);
    
11.             } catch (InterruptedException e) {
    
12.                 e.printStackTrace();
    
13.             }
    
14.             ProductStorage.getInstance().product();
    
15.         }
    
16.     }
    
17. }

3、第三个文件Consumer.java
 

点击(此处)折叠或打开

1. /**
   
2.  * 商品消费者模型
   
3.  */
   
4. public class Consumer implements Runnable{
   
5. 
   
6.     @Override
   
7.     public void run() {
   
8.         while(true){
   
9.             try {
   
10.                 Thread.sleep(1000);
    
11.             } catch (InterruptedException e) {
    
12.                 e.printStackTrace();
    
13.             }
    
14.             ProductStorage.getInstance().consume();
    
15.         }
    
16.         
    
17.     }
    
18. }

4、第四个文件TestMain.java
 

点击(此处)折叠或打开

1. import java.util.concurrent.ExecutorService;
   
2. import java.util.concurrent.Executors;
   
3. 
   
4. public class TestMain {
   
5. 
   
6.     public static void main(String [] args){
   
7.         startProductThread();
   
8.         startConsumThread();
   
9.     }
   
10.     
    
11.     /**
    
12.      * 开启生产者线程
    
13.      */
    
14.     public static void startProductThread(){
    
15.         System.out.println("--生产者线程执行开始--");
    
16.         int pThreadSize = 10;
    
17.         ExecutorService pool = Executors.newFixedThreadPool(pThreadSize);
    
18.         for(int i=0;i<pThreadSize;i++){
    
19.             Producter productThread = new Producter();
    
20.             Thread thread = new Thread(productThread);
    
21.             pool.execute(thread);
    
22.         }
    
23.         System.out.println("--生产者线程执行结束--");
    
24.     }
    
25.     
    
26.     /**
    
27.      * 开启消费者线程
    
28.      */
    
29.     public static void startConsumThread(){
    
30.         System.out.println("--消费者线程执行开始--");
    
31.         int pThreadSize = 10;
    
32.         ExecutorService pool = Executors.newFixedThreadPool(pThreadSize);
    
33.         for(int i=0;i<pThreadSize;i++){
    
34.             Consumer consumeThread = new Consumer();
    
35.             Thread thread = new Thread(consumeThread);
    
36.             pool.execute(thread);
    
37.         }
    
38.         System.out.println("--消费者线程执行结束--");
    
39.     }
    
40. }

5、生产者消费者模式的优点：
（1）将生产模块和消费模块分隔开，从而降低了程序的耦合，便于程序的扩展和维护。
（2）将生产模块和消费模块的分隔，可使生产模块的运行不再依赖消费模块的执行，由同步改为异步执行并且都可支持并发，从而大大提高了程序的效率。
（3）生成者生产的数据存放在缓冲区中，消费者可以按照自己的逻辑来取出数据处理，从而可以有效避免消费模块任务执行负载不均的问题。