java:一个生产者消费者模式的简单实现
先啰嗦一点：
由于最近工作中，涉及到生产者消费者设计模式，对此有一些体会，所以总结一下，与大家分享。
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 类型的缓冲区，服务端接收到业务请求，就往里扔，然后再去接收下一个业务请求，而 多个业务处理线程，就会去缓冲区里取业务请求处理。这样就大大提高了服务器的相 应速度。