生产者模式实现总结2

第二种方法摘自：think in java

下面我们简化一下这个例子。以Think in Java中的例子为原形。大致是这样的，我们将生产者看成是餐厅里的厨师，消费者看成是餐厅里的服务员。厨师会不停的做出食物，而服务员会将厨师做出的食 物拿给顾客。刚开始服务员是处于等待阶段，直到厨师将食物做出来后，他会通知服务员将食物拿走。这时厨师会处于等待阶段，直到服务员将食物拿走后，他会通 知厨师可以继续生产食物。下面是这个例子的代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Restaurant {
Meal meal;
ExecutorService exec = Executors.newCachedThreadPool();
WaitPerson waitPerson = new WaitPerson(this);
Chef chef = new Chef(this);

class Meal {
private final int orderNum;

public Meal(int orderNum) {
this.orderNum = orderNum;

}

public String toString() {
return "Meal" + orderNum;
}
}

class Chef implements Runnable {
private Restaurant restaurant;
private int count;

public Chef(Restaurant r) {
restaurant = r;
}

@Override
public void run() {
// TODO Auto-generated method stub
try {
while (!Thread.interrupted()) {
// 获取自己本身的对象锁
synchronized (this) {
// 如果restaurant中的meal不为空，继续等待
while (restaurant.meal != null) {
wait();// waiter等待meal不为空
}
}
System.out.println(count);
if(++count==10)
{
System.out.println("out of food,closing");
restaurant.exec.shutdownNow();//停止线程
}
System.out.println("order up");
// 获得chef的对象锁，以便于通知chef及时执行操作
synchronized (restaurant.waitPerson) {
restaurant.meal=new Meal(count);
restaurant.waitPerson.notifyAll();

}
}

} catch (InterruptedException e) {

}
}
}

class WaitPerson implements Runnable {
private Restaurant restaurant;

public WaitPerson(Restaurant r) {
restaurant = r;
}

@Override
public void run() {
// TODO Auto-generated method stub
try {
while (!Thread.interrupted()) {
// 获取自己本身的对象锁
synchronized (this) {
// 如果restaurant中的meal为空，循环执行
while (restaurant.meal == null) {
wait();// waiter等待meal不为空
}
}
System.out.println("WaitPerson got  " + restaurant.meal);
// 获得chef的对象锁，以便于通知chef及时执行操作
synchronized (restaurant.chef) {
restaurant.meal = null;// 取走meal
restaurant.chef.notifyAll();// 通知chef可以制造meal

}
TimeUnit.MILLISECONDS.sleep(100);
}
} catch (InterruptedException e) {

}

}
}
Restaurant()
{
exec.execute(chef);
exec.execute(waitPerson);
}

public static void main(String[] args)
{
new Restaurant();

}

}

在这个例子中，并没有用到共享内存（Restaurant）中的同步方法，而是通过在共享内存中获取各个线程的引用，并通过它们加锁后然后相互进行通知，这里使用到了“点对点”通知的方法，即生产者只通知消费者，而不会额外去通知其它生产者。

问题：

在上面的方式显然不太适合多生产者-仓库-多消费者这种模式，这也是它的弊端所在。而在上篇文章介绍的第一种方法里，可以利用共享内存的同步方法，对多个生产者和消费者进行同步！但是这些方法始终都有一个问题，那就是制作效率不高，在同步方法里面，每一时刻只能有一个方法在运行，不能起到多个生产者或多个消费者同时运行，增加“生产能力”/“消费能力”；

备注：

这种方式在java里实现是有些稍显笨拙；在think in java中还介绍了一种生产者-消费者队列（BlockingQueue）的的方法。在这个队列中，可以放入“产品”，如果队列中没有产品，消费者去“消费”的话会自动挂起消费者，知道队列中加入了新的“商品”；