java:一个生产者消费者模式的简单实现

来源：互联网发布：淘宝互联骗局揭秘编辑：程序博客网时间：2024/06/10 01:09

先啰嗦一点：

由于最近工作中，涉及到生产者消费者设计模式，对此有一些体会，所以总结一下，与大家分享。

1、什么是生产者消费者模式

在工作中，大家可能会碰到这样一种情况：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。在生产者与消费者之间在加个缓冲区，我们形象的称之为仓库，生产者负责往仓库了进商品，而消费者负责从仓库里拿商品，这就构成了生产者消费者模式。结构图如下：

1、先上代码，简要说明后再做分析：

a、首先建立一个队列类（WorkQueue）：

package cuu.com.workqueue;
import java.util.LinkedList;
/**
* 队列
* @author DS
*
*/
public class WorkQueue {

/**
* 队列名称
*/
private String name;

/**
* 队列大小
*/
private int size ;

/**
* 队列最大容量
*/
private int upperSize = 100;

/**
* 当前队列容量
*/
private int currentSize;

/**
* 存放对象的集合：存储快、查询慢
*/
private LinkedList queue = new LinkedList();

public String getName() {
  return name;
}
public void setName(String name) {
  this.name = name;
}
public int getCurrentSize() {
  return currentSize;
}
public void setCurrentSize(int currentSize) {
  this.currentSize = currentSize;
}
public LinkedList getQueue() {
  return queue;
}
public void setQueue(LinkedList queue) {
  this.queue = queue;
}
public int getSize() {
  return size;
}
public void setSize(int size) {
  this.size = size;
}

public WorkQueue(String name){
  super();
  this.name = name;
}

public WorkQueue(String name ,int size){
  super();
  this.name = name;
  if(size > upperSize){
   upperSize = size;
  }
}
private int notifySize = 0 ;//生产者工作次数
private int responseSize = 0 ;//消费者工作次数
/**
* 生产者
* @param object
*/
public synchronized void addWork(Object object){
  if(currentSize <= upperSize ){
   //放进集合
   queue.add(object);
   currentSize = queue.size();
   //唤醒消费者
   notifySize++;
   System.out.println(">>>>> 生产者工作完成,开始唤醒消费者,notifySize="+notifySize);
   notify();
  }
}
private int waitSize = 0 ;
/**
* 消费者
* @param object
* @return
*/
public synchronized Object getWork() throws InterruptedException{
  while(queue.isEmpty()){
   waitSize ++;
   System.out.println("仓库没东西, 消费者 waiting..... waitSize= "+ waitSize );
   //消费者释放对象锁，由生产者获取这个对象锁
   wait();
  }

  //移除并返回第一个元素
  Object object = queue.removeFirst();
  currentSize = queue.size();
  responseSize ++;
  System.out.println("**消费者工作完成,开始唤醒生产者,responseSize="+responseSize);
  return object;
}

}

b、上面的队列类负责处理数据的读写。那么，我们还需要一个队列管理者来管理这些队列

package cuu.com.workqueue;

/**
* 队列管理者
* @author DS
*
*/
public class EventQueueManager {

/**
* 接收NETBAR数据队列
*/
public static WorkQueue receiveDataQueue = new WorkQueue("receiveDataQueue");

/**
* 接收LOCATOIN数据队列
*/
public static WorkQueue receiveFjDataQueue = new WorkQueue("receiveDataQueue");

}

c、上面的队列管理类中会有很多的队列类的实例，每个实例负责一种数据的处理；接下来就是客户端的代码：

package cuu.com.workqueue;

public class TestQueue {

private Integer id;

private String serviceCode;

private String serviceName;

private String address;

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public String getServiceCode() {
return serviceCode;
}

public void setServiceCode(String serviceCode) {
this.serviceCode = serviceCode;
}

public String getServiceName() {
return serviceName;
}

public void setServiceName(String serviceName) {
this.serviceName = serviceName;
}

public String getAddress() {
return address;
}

public void setAddress(String address) {
this.address = address;
}

public String toString() {
  System.out.println("id="+getId()+",serviceCode="+getServiceCode()+",serviceName="+getServiceName()+",address="+getAddress()+"");
  return "id="+getId()+",serviceCode="+getServiceCode()+",serviceName="+getServiceName()+",address="+getAddress()+"";
}

public TestQueue () {
  new PentagonThread().start();//当然也可以多个线程来处理数据
}

private boolean running = false;

public static void main(String[] args) {
  for (int i = 0; i < 50; i++) {
   TestQueue queue = new TestQueue();
   queue.setId(new Integer(i));
   queue.setAddress("美国五角大楼_00"+i+"号");
   queue.setServiceCode("00012_"+i+"");
   queue.setServiceName("听风者00"+i+"码");
   EventQueueManager.receiveDataQueue.addWork(queue);//生产数据
  }
}

class PentagonThread extends Thread {

  public void run() {
   if (running == true){
    return;
   }
   running = true;
   process();
  }

}

/**
* 真正执行
*/
public void process() {
    try {
    TestQueue queue = (TestQueue) EventQueueManager.receiveDataQueue.getWork();//消费数据
    if(queue != null){
     //queue.toString();
    }
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
}

}

测试结果：

第一次测试：

仓库没东西, 消费者 waiting..... waitSize= 1
>>>> 生产者工作完成,开始唤醒消费者,notifySize=1
*消费者工作完成,开始唤醒生产者,responseSize=1
>>>> 生产者工作完成,开始唤醒消费者,notifySize=2
*消费者工作完成,开始唤醒生产者,responseSize=2
>>>> 生产者工作完成,开始唤醒消费者,notifySize=3
*消费者工作完成,开始唤醒生产者,responseSize=3
>>>> 生产者工作完成,开始唤醒消费者,notifySize=4
>>>> 生产者工作完成,开始唤醒消费者,notifySize=5
>>>> 生产者工作完成,开始唤醒消费者,notifySize=6
*消费者工作完成,开始唤醒生产者,responseSize=4
>>>> 生产者工作完成,开始唤醒消费者,notifySize=7
*消费者工作完成,开始唤醒生产者,responseSize=5
>>>> 生产者工作完成,开始唤醒消费者,notifySize=8
*消费者工作完成,开始唤醒生产者,responseSize=6
>>>> 生产者工作完成,开始唤醒消费者,notifySize=9
*消费者工作完成,开始唤醒生产者,responseSize=7
*消费者工作完成,开始唤醒生产者,responseSize=8
*消费者工作完成,开始唤醒生产者,responseSize=9
挚?没东西, 消费者 waiting..... waitSize= 2
>>>> 生产者工作完成,开始唤醒消费者,notifySize=10
>>>> 生产者工作完成,开始唤醒消费者,notifySize=11
*消费者工作完成,开始唤醒生产者,responseSize=10
*消费者工作完成,开始唤醒生产者,responseSize=11
>>>> 生产者工作完成,开始唤醒消费者,notifySize=12
*消费者工作完成,开始唤醒生产者,responseSize=12
>>>> 生产者工作完成,开始唤醒消费者,notifySize=13
>>>> 生产者工作完成,开始唤醒消费者,notifySize=14
*消费者工作完成,开始唤醒生产者,responseSize=13
*消费者工作完成,开始唤醒生产者,responseSize=14
>>>> 生产者工作完成,开始唤醒消费者,notifySize=15
*消费者工作完成,开始唤醒生产者,responseSize=15
挚?没东西, 消费者 waiting..... waitSize= 3
>>>> 生产者工作完成,开始唤醒消费者,notifySize=16
*消费者工作完成,开始唤醒生产者,responseSize=16
>>>> 生产者工作完成,开始唤醒消费者,notifySize=17
*消费者工作完成,开始唤醒生产者,responseSize=17
>>>> 生产者工作完成,开始唤醒消费者,notifySize=18
*消费者工作完成,开始唤醒生产者,responseSize=18
>>>> 生产者工作完成,开始唤醒消费者,notifySize=19
>>>> 生产者工作完成,开始唤醒消费者,notifySize=20
*消费者工作完成,开始唤醒生产者,responseSize=19
*消费者工作完成,开始唤醒生产者,responseSize=20
>>>> 生产者工作完成,开始唤醒消费者,notifySize=21
*消费者工作完成,开始唤醒生产者,responseSize=21
挚?没东西, 消费者 waiting..... waitSize= 4
>>>> 生产者工作完成,开始唤醒消费者,notifySize=22
*消费者工作完成,开始唤醒生产者,responseSize=22
>>>> 生产者工作完成,开始唤醒消费者,notifySize=23
*消费者工作完成,开始唤醒生产者,responseSize=23
>>>> 生产者工作完成,开始唤醒消费者,notifySize=24
*消费者工作完成,开始唤醒生产者,responseSize=24
>>>> 生产者工作完成,开始唤醒消费者,notifySize=25
*消费者工作完成,开始唤醒生产者,responseSize=25
>>>> 生产者工作完成,开始唤醒消费者,notifySize=26
>>>> 生产者工作完成,开始唤醒消费者,notifySize=27
*消费者工作完成,开始唤醒生产者,responseSize=26
*消费者工作完成,开始唤醒生产者,responseSize=27
>>>> 生产者工作完成,开始唤醒消费者,notifySize=28
*消费者工作完成,开始唤醒生产者,responseSize=28
>>>> 生产者工作完成,开始唤醒消费者,notifySize=29
*消费者工作完成,开始唤醒生产者,responseSize=29
>>>> 生产者工作完成,开始唤醒消费者,notifySize=30
*消费者工作完成,开始唤醒生产者,responseSize=30
>>>> 生产者工作完成,开始唤醒消费者,notifySize=31
*消费者工作完成,开始唤醒生产者,responseSize=31
>>>> 生产者工作完成,开始唤醒消费者,notifySize=32
*消费者工作完成,开始唤醒生产者,responseSize=32
>>>> 生产者工作完成,开始唤醒消费者,notifySize=33
*消费者工作完成,开始唤醒生产者,responseSize=33
>>>> 生产者工作完成,开始唤醒消费者,notifySize=34
*消费者工作完成,开始唤醒生产者,responseSize=34
>>>> 生产者工作完成,开始唤醒消费者,notifySize=35
*消费者工作完成,开始唤醒生产者,responseSize=35
>>>> 生产者工作完成,开始唤醒消费者,notifySize=36
*消费者工作完成,开始唤醒生产者,responseSize=36
>>>> 生产者工作完成,开始唤醒消费者,notifySize=37
*消费者工作完成,开始唤醒生产者,responseSize=37
>>>> 生产者工作完成,开始唤醒消费者,notifySize=38
*消费者工作完成,开始唤醒生产者,responseSize=38
>>>> 生产者工作完成,开始唤醒消费者,notifySize=39
*消费者工作完成,开始唤醒生产者,responseSize=39
>>>> 生产者工作完成,开始唤醒消费者,notifySize=40
*消费者工作完成,开始唤醒生产者,responseSize=40
挚?没东西, 消费者 waiting..... waitSize= 5
>>>> 生产者工作完成,开始唤醒消费者,notifySize=41
*消费者工作完成,开始唤醒生产者,responseSize=41
>>>> 生产者工作完成,开始唤醒消费者,notifySize=42
*消费者工作完成,开始唤醒生产者,responseSize=42
>>>> 生产者工作完成,开始唤醒消费者,notifySize=43
*消费者工作完成,开始唤醒生产者,responseSize=43
>>>> 生产者工作完成,开始唤醒消费者,notifySize=44
*消费者工作完成,开始唤醒生产者,responseSize=44
>>>> 生产者工作完成,开始唤醒消费者,notifySize=45
*消费者工作完成,开始唤醒生产者,responseSize=45
>>>> 生产者工作完成,开始唤醒消费者,notifySize=46
*消费者工作完成,开始唤醒生产者,responseSize=46
>>>> 生产者工作完成,开始唤醒消费者,notifySize=47
*消费者工作完成,开始唤醒生产者,responseSize=47
>>>> 生产者工作完成,开始唤醒消费者,notifySize=48
*消费者工作完成,开始唤醒生产者,responseSize=48
>>>> 生产者工作完成,开始唤醒消费者,notifySize=49
*消费者工作完成,开始唤醒生产者,responseSize=49
>>>> 生产者工作完成,开始唤醒消费者,notifySize=50
*消费者工作完成,开始唤醒生产者,responseSize=50

第二次测试：

仓库没东西, 消费者 waiting..... waitSize= 1
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=1
**消费者工作完成,开始唤醒生产者,responseSize=1
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=2
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=3
**消费者工作完成,开始唤醒生产者,responseSize=2
**消费者工作完成,开始唤醒生产者,responseSize=3
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=4
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=5
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=6
**消费者工作完成,开始唤醒生产者,responseSize=4
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=7
**消费者工作完成,开始唤醒生产者,responseSize=5
**消费者工作完成,开始唤醒生产者,responseSize=6
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=8
**消费者工作完成,开始唤醒生产者,responseSize=7
**消费者工作完成,开始唤醒生产者,responseSize=8
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=9
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=10
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=11
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=12
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=13
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=14
**消费者工作完成,开始唤醒生产者,responseSize=9
**消费者工作完成,开始唤醒生产者,responseSize=10
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=15
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=16
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=17
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=18
**消费者工作完成,开始唤醒生产者,responseSize=11
**消费者工作完成,开始唤醒生产者,responseSize=12
**消费者工作完成,开始唤醒生产者,responseSize=13
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=19
**消费者工作完成,开始唤醒生产者,responseSize=14
**消费者工作完成,开始唤醒生产者,responseSize=15
**消费者工作完成,开始唤醒生产者,responseSize=16
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=20
**消费者工作完成,开始唤醒生产者,responseSize=17
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=21
**消费者工作完成,开始唤醒生产者,responseSize=18
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=22
**消费者工作完成,开始唤醒生产者,responseSize=19
**消费者工作完成,开始唤醒生产者,responseSize=20
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=23
**消费者工作完成,开始唤醒生产者,responseSize=21
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=24
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=25
**消费者工作完成,开始唤醒生产者,responseSize=22
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=26
**消费者工作完成,开始唤醒生产者,responseSize=23
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=27
**消费者工作完成,开始唤醒生产者,responseSize=24
**消费者工作完成,开始唤醒生产者,responseSize=25
**消费者工作完成,开始唤醒生产者,responseSize=26
**消费者工作完成,开始唤醒生产者,responseSize=27
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=28
**消费者工作完成,开始唤醒生产者,responseSize=28
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=29
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=30
**消费者工作完成,开始唤醒生产者,responseSize=29
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=31
**消费者工作完成,开始唤醒生产者,responseSize=30
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=32
**消费者工作完成,开始唤醒生产者,responseSize=31
**消费者工作完成,开始唤醒生产者,responseSize=32
仓库没东西, 消费者 waiting..... waitSize= 2
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=33
**消费者工作完成,开始唤醒生产者,responseSize=33
仓库没东西, 消费者 waiting..... waitSize= 3
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=34
**消费者工作完成,开始唤醒生产者,responseSize=34
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=35
**消费者工作完成,开始唤醒生产者,responseSize=35
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=36
**消费者工作完成,开始唤醒生产者,responseSize=36
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=37
**消费者工作完成,开始唤醒生产者,responseSize=37
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=38
**消费者工作完成,开始唤醒生产者,responseSize=38
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=39
**消费者工作完成,开始唤醒生产者,responseSize=39
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=40
**消费者工作完成,开始唤醒生产者,responseSize=40
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=41
**消费者工作完成,开始唤醒生产者,responseSize=41
仓库没东西, 消费者 waiting..... waitSize= 4
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=42
**消费者工作完成,开始唤醒生产者,responseSize=42
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=43
**消费者工作完成,开始唤醒生产者,responseSize=43
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=44
**消费者工作完成,开始唤醒生产者,responseSize=44
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=45
**消费者工作完成,开始唤醒生产者,responseSize=45
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=46
**消费者工作完成,开始唤醒生产者,responseSize=46
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=47
**消费者工作完成,开始唤醒生产者,responseSize=47
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=48
**消费者工作完成,开始唤醒生产者,responseSize=48
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=49
**消费者工作完成,开始唤醒生产者,responseSize=49
>>>>> 生产者工作完成,开始唤醒消费者,notifySize=50
**消费者工作完成,开始唤醒生产者,responseSize=50

结合以上的实现，总结如下：

2、生产者消费者模式的优点

1、解耦

假设生产者和消费者分别是两个类。如果让生产者直接调用消费者的某个方法，那么生产者对于消费者就会产生依赖（也就是耦合）。将来如果消费者的代码发生变化，可能会影响到生产者。而如果两者都依赖于某个缓冲区，两者之间不直接依赖，耦合也就相应降低了。

举个例子，我们去邮局投递信件，如果不使用邮筒（也就是缓冲区），你必须得把信直接交给邮递员。有同学会说，直接给邮递员不是挺简单的嘛？其实不简单，你必须得认识谁是邮递员，才能把信给他（光凭身上穿的制服，万一有人假冒，就惨了）。这就产生和你和邮递员之间的依赖（相当于生产者和消费者的强耦合）。万一哪天邮递员换人了，你还要重新认识一下（相当于消费者变化导致修改生产者代码）。而邮筒相对来说比较固定，你依赖它的成本就比较低（相当于和缓冲区之间的弱耦合）。

2、支持并发

由于生产者与消费者是两个独立的并发体，他们之间是用缓冲区作为桥梁连接，生产者只需要往缓冲区里丢数据，就可以继续生产下一个数据，而消费者只需要从缓冲区了拿数据即可，这样就不会因为彼此的处理速度而发生阻塞。

接上面的例子，如果我们不使用邮筒，我们就得在邮局等邮递员，直到他回来，我们把信件交给他，这期间我们啥事儿都不能干（也就是生产者阻塞），或者邮递员得挨家挨户问，谁要寄信（相当于消费者轮询）。

3、支持忙闲不均

缓冲区还有另一个好处。如果制造数据的速度时快时慢，缓冲区的好处就体现出来了。当数据制造快的时候，消费者来不及处理，未处理的数据可以暂时存在缓冲区中。等生产者的制造速度慢下来，消费者再慢慢处理掉。

为了充分复用，我们再拿寄信的例子来说事。假设邮递员一次只能带走1000封信。万一某次碰上情人节（也可能是圣诞节）送贺卡，需要寄出去的信超过1000封，这时候邮筒这个缓冲区就派上用场了。邮递员把来不及带走的信暂存在邮筒中，等下次过来时再拿走。

3、实际应用

在我们的数据接收R项目中，数据接收服务器要接受大批量的客户端请求处理，一开始，每天要处理的数据最多也就100W, 随着业务点的增多，数据越来越多，每天的平均数据达到百万级别（重要地区的数据量甚至达到千万）；原始的哪种串行化处理根本来不及，这样就造成了大量数据的丢失，也造成了严重的后果；之后就采用了生产者消费者模式，在业务请求与业务处理间，建立了一个List 类型的缓冲区，服务端接收到业务请求，就往里扔，然后再去接收下一个业务请求，而多个业务处理线程，就会去缓冲区里取业务请求处理。这样就大大提高了服务器的相应速度。