Java 使用notifyAll()和wait()实现一个简易生产者和消费者

转载自：《Java编程思想（第四版）》p709-711
请考虑这样一个饭店，它有一个厨师和一个服务员。这个服务员必须等待厨师准备好膳食。当厨师准备好时，他会通知服务员，之后服务员上菜，然后返回继续等待。这是一个任务协作的示例:厨师代表生产者，而服务员代表消费者。两个任务必须在食被生产和消费时进行握手，而系统必须以有序的方式关闭。下面是对这个叙述建模的代码：

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

class Meal {
    private final int orderNum;

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

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

class WaitPerson implements Runnable {

    private Restaurant restaurant;

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

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                synchronized (this) {
                    while (restaurant.meal == null)
                        wait();//当没有食物时，消费者等待厨师做食物

                }
                System.out.println("WaitPerson got meal :"+restaurant.meal);
                synchronized (restaurant.chef) {
                    restaurant.meal = null;//把食物消耗掉
                    restaurant.chef.notifyAll();//唤醒生产者，让开始做另一份食物
                }
            }
        } catch (InterruptedException e) {
            System.out.println("WaitPerson interrupted");
        }
    }
}

class Chef implements Runnable {
    private Restaurant restaurant;
    private int count = 0;
    public Chef(Restaurant r) {
        restaurant = r;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                synchronized (this) {//当得到自己的锁
                    while (restaurant.meal!=null)
                        wait();//如果有食物，就等待食物被消费
                }
                if (++count== 10) {
                    System.out.println("Out of foods，close.");
                    restaurant.exec.shutdownNow();//执行1.次后让线程池中断线程
                }
                System.out.print("Oder up! ");
                synchronized (restaurant.waitPerson) {//当得到消费者的锁
                    restaurant.meal = new Meal(count);//生产食物
                    restaurant.waitPerson.notifyAll();//唤醒消费者
                }
                TimeUnit.MILLISECONDS.sleep(100);
            }
        } catch (InterruptedException e) {
            System.out.println("Chef interrupted");
        }
    }
}

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

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

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

Restaurant是 Wait Person和Chef的焦点，他们都必须知道在为哪个 Restaurant工作，因为他们必须和这这家饭店的的“餐窗”打交道，以便放置或拿取膳食 restaurant.meal。在run()中，WaitPerson进入wait()模式，停止其任务，直至被Chef的 notifyAll()唤醒。由于这是一个非常单的程序，因此我们知道只有一个任务将在 WaitPerson的锁上等待:即 WaitPerson任务自身出于这个原因，理论上可以调用 notify()而不是 notifyAll()。但是，在更复杂的情况下，可能会有多个任务在某个特定对象锁上等待，因此你不知道哪个任务应该被唤醒醒。因此，调用 notifyAll()要更安全一些，这样可以唤醒等待这个锁的所有任务，而每个任务都必须决定这个通知是否与自己相关。
一旦Chef送上Meal并通知 WaitPerson，这个Chef就将等待，直至 WaitPerson收集到订单并通知Chef，之后Chef就可以烧下一份 Meal了.
注意，wait()被包装在一个 while语句中，这个语句在不断地测试正在等待的事物。咋看上去这有点怪一一如果在等待一个订单，一旦你被唤醒，这个订单就必定是可获得的，对吗?正如前面注意到的，问题是在并发应用中，某个其他的任务可能会在waitPerson被唤醒时，会突然插足并拿走订单，唯一安全的方式是使用下面这种wait()惯用的用法(当然要在恰当的同步内部，并采用防止错失信号可能性的程序设计)

while(conditonIsNotMet){
wait();
}

这可以保证在你退出等待循环之前，条件将得到满足，并且如果你收到了关于某事物的通知，而它与这个条件并无关系(就象在使用 notifyAll()时可能发生的情况一样)，或者在你完全退出等待循环之前，这个条件发生了变化，都可以确保你可以重返等待状态。
请注意观察，对notifyAllo()的调用必须首先捕获 WaitPerson上的锁，而在 WaitPerson.run()中的对wait()的调用会自动地释放这个锁，因此这是有可能实现的。因为调用 notifyAll()必然拥有这个锁，所以这可以保证两个试图在同一个对象上调用 notifyalloa的任务不会互相冲突。
通过把整个run()方法体放到一个try语句块中，可使得这两个run()方法都被设计为可以有序地关闭。 catch子句将紧挨着run()方法的结束括号之前结束，因此，如果这个任务收到了InterruptedException异常，它将在捕获异常之后立即结束。
注意，在Chef中，在调用 shutdownNow()之后，你应该直接从run()返回，并且通常这就是你应该做的。但是，以这种方式执行还有一些更有趣的东西。记住， shutdownNow()将向所有由 ExecutorService启动的任务发送 interrupt()，但是在Chef中，任务并没有在获得该 interrupt()之后立即关闭，因为当任务试图进入一个(可中断的)阻塞操作时，这个中断只能抛出InterruptedException。因此，你将看到首先显示了“ Order up!”，然后当Chef试图调用 sleep()时，抛出了 InterruptedException。如果移除对sleep()的调用，那么这个任务将回溯到run()循环的顶部，并由于 Thread.interrupted()测试而退出，同时并不抛出异常。