生产者与消费者模式

本文是在搜集网络上的相关知识的基础上实现的

虽然生产者-消费者模式能够将生产者和消费者的代码彼此解耦开来，但它们的行为仍然会通过共享工作队列间接滴耦合在一起。开发人员总会假设消费者处理工作的速率能够赶上生产者生产工作项的速率。

在类库中存在BlockingQueue的多种实现，其中，

LinkedBlockingQueue和ArrayBlockingQueue是FIFO队列。

PriorityBlockingQueue是一个按照优先级排序的队列，当你希望按照某种顺序而不是FIFO来处理元素时，这个队列将非常有用。

最后一个是SynchronousQueue，它维护一组线程，这些线程在等待着把元素加入或移除队列，可以直接交付工作，降低了将数据从生产者到消费者的延迟。因为SynchronousQueue没有存储功能，因此put和take会一直阻塞，直到有另外一个线程已经准备好参与到交付过程中，仅当有足够的消费者，并且总是有一个消费者准备好获取交付的工作时，才适合使用同步队列。

下面写一个用BlockingQueue实现的生产者与消费者模式

package kevin;


import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;


/**
 * 一个简单的生产者-消费者demo
 * 
 * @author KevinJom
 */
public class BlockingQueueDemo {
public static void main(String[] args) {
new BlockingQueueDemo().go();
}


private void go() {
// 这里简单的说一下BlockingQueue的实现,它基于生产者-消费者模式，其中有两个重要的阻塞方法
// put()和take()，而这两个方法的实现用到了Lock和Condition，具体实现请参考API
BlockingQueue<String> queue = new ArrayBlockingQueue<String>(10);
Thread t1 = new Thread(new Producer(queue, 500, "peak")); // 生产者线程,来，生产一些i
// can
// play吧，并且要比nike生产的快
Thread t2 = new Thread(new Producer(queue, 1000, "nike")); // 第二个生产者线程
Thread t3 = new Thread(new Customer(queue)); // 消费者线程
t1.start();
t2.start();
t3.start();
}


private class Producer implements Runnable {
private BlockingQueue<String> queue;
private int timeout; // 生产一个产品后暂停的时间
private String category; // 仅仅起标记产品作用


public Producer(BlockingQueue<String> queue, int timeout,
String category) {
super();
this.queue = queue;
this.timeout = timeout;
this.category = category;
}


@Override
public void run() {
while (!Thread.currentThread().isInterrupted()) {
try {
// put()方法也是一个会阻塞的方法，如果队列已满的时候这个方法会一起阻塞直到
// 队列中重新出现空间为止
queue.put("product " + category);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
try {
TimeUnit.MILLISECONDS.sleep(timeout); // 每生产一个产品就暂停timeout毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}


private class Customer implements Runnable {
private BlockingQueue<String> queue;


public Customer(BlockingQueue<String> queue) {
super();
this.queue = queue;
}


@Override
public void run() {
while (!Thread.currentThread().isInterrupted()) {
try {
System.out.println("product got:" + queue.take());
} catch (InterruptedException e1) {
e1.printStackTrace();
}
try {
// 暂停10毫秒，这里主要是为了证明take()是一个阻塞方法，如果 BlockingQueue中
// 没有元素，它会一起阻塞直到队列中有元素为止
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}


}


}


}