以下文字出自:http://canofy.iteye.com/blog/411408
在实际的软件开发过程中,经常会碰到如下场景:某个模块负责产生数据,这些数据由另一个模块来负责处理(此处的模块是广义的,可以是类、函数、线程、进程 等)。产生数据的模块,就形象地称为生产者;而处理数据的模块,就称为消费者。
单单抽象出生产者和消费者,还够不上是生产者/消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间,作为一个中介。生产者把数据放入缓 冲区,而消费者从缓冲区取出数据
◇解耦
假设生产者和消费者分别是两个类。如果让生产者直接调用消费者的某个方法,那么生产者对于消费者就会产生依赖(也就是耦合)。将来如果消费者 的代码发生变化,可能会影响到生产者。而如果两者都依赖于某个缓冲区,两者之间不直接依赖,耦合也就相应降低了。
◇支持并发(concurrency)
生产者直接调用消费者的某个方法,还有另一个弊端。由于函数调用是同步的(或者叫阻塞的),在消费者的方法没有返回之前,生产者只好一直等在 那边。万一消费者处理数据很慢,生产者就会白白糟蹋大好时光。
使用了生产者/消费者模式之后,生产者和消费者可以是两个独立的并发主体(常见并发类型有进程和线程两种,后面的帖子会讲两种并发类型下的应 用)。生产者把制造出来的数据往缓冲区一丢,就可以再去生产下一个数据。基本上不用依赖消费者的处理速度。其实当初这个模式,主要就是用来处理并发问题 的。
◇支持忙闲不均
缓冲区还有另一个好处。如果制造数据的速度时快时慢,缓冲区的好处就体现出来了。当数据制造快的时候,消费者来不及处理,未处理的数据可以暂 时存在缓冲区中。等生产者的制造速度慢下来,消费者再慢慢处理掉。
自己写了个简单的程序...
class Producer implements Runnable {//生产者
Queue queue;
public Producer(Queue q){
queue = q;
}
@Override
public void run() {
for(int i=0;i<10;i++){
queue.put(i);
System.out.println("producter: "+i);
}
}
}
class Consumer implements Runnable {//消费者
Queue queue;
public Consumer(Queue q) {
queue = q;
}
@Override
public void run() {
for(int i = 0; i < 10; i++){
System.out.println("Consumer: "+queue.get());
}
}
}
class Queue {//缓冲区,这里以队列来表示
int value;
boolean bFull = false;
public synchronized void put(int i){
if(!bFull){
value = i;
bFull = true;
notify();
}
try {
wait();
} catch (Exception e) {
e.printStackTrace();
}
}
public synchronized int get(){
if(!bFull){
try {
wait();
} catch (Exception e) {
e.printStackTrace();
}
}
bFull = false;
notify();
return value;
}
}
public class Test {//测试类
public static void main(String[] args){
Queue queue = new Queue();
Producer producer = new Producer(queue);
Consumer consumer = new Consumer(queue);
Thread t1 = new Thread(producer);
Thread t2 = new Thread(consumer);
t1.start();
t2.start();
}
}