Java多线程编程中生产者-消费者模式的详解

生产者-消费者模式是一个经典的多线程设计模式，它为多线程的协作提供了良好的解决方案。在生产者-消费者模式中，通常有两类线程，即若干个生产者线程和若干个消费者线程。生产者线程负责提交用户请求，消费者线程负责处理用户请求。生产者和消费者之间通过共享内存缓冲区进行通信。

生产者-消费者模式中的内存缓冲区的主要功能是数据在多线程间的共享。此外，通过该缓冲区，可以缓解生产者和消费者之间的性能差。

Java多线程编程中，常用的多线程设计模式包括：Future模式、Master-Worker模式、Guarded Suspeionsion模式、不变模式和生产者-消费者模式等。这篇文章主要讲述不变模式，关于其他多线程设计模式的地址如下：
关于Future模式的详解： Java多线程编程中Future模式的详解
关于Master-Worker模式的详解： Java多线程编程中Master-Worker模式的详解
关于Guarded Suspeionsion模式的详解： Java多线程编程中Guarded Suspeionsion模式的详解
关于不变模式的详解： Java多线程编程中不变模式的详解

下面以生产者生产馒头、消费者吃馒头为例说明生产者-消费者模式，并用Java代码实现。

1. 馒头

这里采用了面向对象的设计思想，馒头在整个程序中自然是一个类，其Java代码如下。

[java] view plain copy

1. class ManTou {  
2.     int id;  
3.     ManTou(int id) {  
4.         this.id = id;  
5.     }  
6.       
7.     public String toString() {  
8.         return "ManTou: " + id;  
9.     }  
10. }  

2. 篮子（装馒头）

篮子是有容量的，因此篮子类需要有一个变量表示容量；篮子至少还有取和装馒头这两个功能，其Java代码如下：

[java] view plain copy

1. class SyncStack { //篮子  
2.     int index = 0;  
3.     ManTou[] arrMT = new ManTou[6]; //假设这个篮子只能装6个馒头  
4.       
5.     public synchronized void push(ManTou wt) { //装馒头  
6.         while(index == arrMT.length) { //篮子满了  
7.             try {  
8.                 this.wait();  
9.             } catch (InterruptedException e) {  
10.                 e.printStackTrace();  
11.             }  
12.         }  
13.         this.notify(); //如果取馒头的wait了，则通知他醒来  
14.         arrMT[index] = wt;  
15.         index ++;  
16.     }  
17.       
18.     public synchronized ManTou pop() { //取馒头  
19.         while(index == 0) { //篮子空了  
20.             try {  
21.                 this.wait();  
22.             } catch (InterruptedException e) {  
23.                 e.printStackTrace();  
24.             }  
25.         }  
26.         this.notify(); //如果产馒头的wait了，则通知他醒来  
27.         index --;  
28.         return arrMT[index];  
29.           
30.     }  
31. }  

3. 生产者（生产馒头）

生产者需要获取篮子这个对象，而且篮子不能是自己创建的。其Java代码如下：

[java] view plain copy

1. class Producer implements Runnable { //生产者  
2.     SyncStack ss = null;  
3.       
4.     Producer(SyncStack ss) {  
5.         this.ss = ss;  
6.     }  
7.       
8.     public void run() {  
9.         for(int i=0; i<20; i++) { //一共要生成20个  
10.             ManTou wt = new ManTou(i);  
11.             ss.push(wt);  
12.             System.out.println("生产了：" + wt);  
13.             try { //生成一个睡1秒，便于观察  
14.                 Thread.sleep((long) (Math.random() * 1000));  
15.             } catch (InterruptedException e) {  
16.                 e.printStackTrace();  
17.             }  
18.         }  
19.     }  
20. }  

4. 消费者（吃馒头）

消费需要获取篮子这个对象，而且这个对象必须与生产者获取的篮子是同一个对象，这样才能信息共享。其Java代码如下：

[java] view plain copy

1. class Consumer implements Runnable {  
2.     SyncStack ss = null;  
3.       
4.     Consumer(SyncStack ss) {  
5.         this.ss = ss;  
6.     }  
7.     public void run() {  
8.         for(int i=0; i<20; i++) { //一共要吃20个  
9.             ManTou wt = ss.pop();  
10.             System.out.println("消费了：" + wt);  
11.         }  
12.     }  
13. }  

5. 测试运行

主函数Java代码如下：

[java] view plain copy

1. public class ProducerConsumer {  
2.     public static void main(String[] args) {  
3.         SyncStack ss = new SyncStack(); //定义篮子  
4.         Producer p = new Producer(ss);  //定义生产者  
5.         Consumer c = new Consumer(ss);  //定义消费者  
6.         new Thread(p).start();  
7.         new Thread(c).start();  
8.     }  
9. }  

运行上述结果，后台打印如下：

全文完。转载请注明出处。

参考文献

1. 葛一鸣，Java程序性能优化．清华大学出版社．

2. 北京尚学堂辅导机构网络视频．