等待/通知模式中最经典的案例当属生产者/消费者模式，此模式有几种变形，但都是基于wait/notify的。
生产者/消费者模式有两种类型：操作值的和操作栈的。下面分别从这两方面来讲解生产者/消费者模式。
操作值
①一生产与一消费
public class P { private String lock; //操作值 public P(String lock){ this.lock = lock; } public void setValue(){ synchronized(lock){ if(!ValueObject.value.equals("")){ lock.wait(); } String value = System.currentTimeMillis(); ValueObject.value = value; lock.notify(); } } } public class C { private String lock; //操作值 public C(String lock){ this.lock = lock; } public void getValue(){ synchronized(lock){ if(ValueObject.value.equals("")){ lock.wait(); } ValueObject.value = ""; lock.notify(); } } } public class ValueObject { public static String value = ""; } public class ThreadP extends Thread { private P p; public ThreadP(P p){ this.p = p; } public void run(){ while(true){ p.setValue(); } } } public class ThreadC extends Thread { private C c; public ThreadC(C c){ this.c = c; } public void run(){ while(true){ c.getValue(); } } } public class Run{ public static void main(String [] args){ String lock = new String(""); P p = new P(lock); C c = new C(lock); ThreadP tp = new ThreadP(p); ThreadC tc = new ThreadC(c); tp.start(); tc.start(); } } 运行结果：不断地循环运行生产者的setValue方法和消费者的getValue方法，不停的交换数据。分析：tp线程首先运行，lock == “”，生产者p发现尚未生产，所以先生产，在下一次循环中发现value ！= “”；即生产出的产品尚未被消费，所以先等待进入wait状态。tc线程开始运行，发现 value！=“”，产品还没有被消费，所以先消费，在下一次循环中发现 value == “”，即生产者还没有生产，所以进入wait状态，让出控制权，让生产者继续生产...进入一种无限循环中。
②多生产与多消费：操作值--有可能进入假死状态
public class P { private String lock; //操作值 public P(String lock){ this.lock = lock; } public void setValue(){ synchronized(lock){ while(!ValueObject.value.equals("")){ lock.wait(); } String value = System.currentTimeMillis(); ValueObject.value = value; lock.notify(); } } } public class C { private String lock; //操作值 public C(String lock){ this.lock = lock; } public void getValue(){ synchronized(lock){ while(ValueObject.value.equals("")){ lock.wait(); } ValueObject.value = ""; lock.notify(); } } } public class ValueObject { public static String value = ""; } public class ThreadP extends Thread { private P p; public ThreadP(P p){ this.p = p; } public void run(){ while(true){ p.setValue(); } } } public class ThreadC extends Thread { private C c; public ThreadC(C c){ this.c = c; } public void run(){ while(true){ c.getValue(); } } } public class Run{ public static void main(String [] args){ String lock = new String(""); P p = new P(lock); C c = new C(lock); ThreadP tp1 = new ThreadP(p); ThreadP tp2 = new ThreadP(p); ThreadC tc1 = new ThreadC(c); ThreadC tc1 = new ThreadC(c); tp1.start(); tc1.start(); tp2.start(); tc2.start(); } } 运行结果：极有可能出现假死情况，即四个线程都处于wait状态。分析：首先生产者1在检查了条件，即value==“”后开始生产，然后调用notify方法，在下一次while循环检查条件是发现value ！= “”；进入wait状态；下一次若被生产者2抢到控制权，发现已经生产，则生产者2直接进入wait状态。然后消费者1检查发现value ！= “”，开始消费，在下一次while循环中，发现value == “”，即尚未生产，则进入wait状态，这时若消费者2抢到了锁， 也发现尚未生产，则也进入wait状态；生产者1又一次抢到了锁，开始生产，在下一次while循环中，发现尚未消费，进入了wait状态；此时若又由生产者2拿到了锁，它发现尚未消费，则也进入wait状态。现在，四个进程都在等待，进入了假死状态。
“假死”状态是因为线程连续唤醒同类造成的，生产者1唤醒生产者2，消费者1唤醒消费者2。如何解决？不仅唤醒同类，而且将异类也一起唤醒。即将生产者和消费者中的notify方法换为notifyAll方法。
操作栈
①一生产与一消费
public class MyStack { private List list = new ArrayList(); //操作栈synchronized public void push(){ if(list.size() == 1){ this.wait(); } list.add("str"); this.notify(); } synchronized public void pop(){ if(list.size() == 0){ this.wait(); } list.remove(0); this.notify(); } } public class P { private MyStack myStack; public P(MyStack s){ this.myStack = s; } public void pushService(){ myStack.push(); } } public class C { private MyStack myStack; public C(MyStack s){ this.myStack = s; } public void popService(){ myStack.pop(); } } public class ThreadP extends Thread { private P p; public ThreadP(P p){ this.p = p; } public void run(){ while(true){ p.pushService(); } } } public class ThreadC extends Thread { private C c; public ThreadC(C c){ this.c = c; } public void run(){ while(true){ c.popService(); } } } public class Run{ public static void main(String [] args){ MyStack muStack= new MyStack(); P p = new P(myStack); C c = new C(myStack); ThreadP tp = new ThreadP(p); ThreadC tc = new ThreadC(c); tp.start(); tc.start(); } } 运行结果：size不会超过1，生产和消费过程在轮流执行。分析：生产者首先运行，size==0，首先生产，在下一次while循环是进入wait状态；消费者运行，首先消费，在下一次while循环时发现还未生产，进入wait状态。唤醒生产者进行生产。。。不断循环此过程。
②一生产和多消费---可能遭遇条件改变抛出的异常和假死情况
上例的代码不进行更改，只修改运行类如下： public class Run{ public static void main(String [] args){ MyStack muStack= new MyStack(); P p = new P(myStack); C c1 = new C(myStack); C c2 = new C(myStack); C c3 = new C(myStack); C c4 = new C(myStack); C c5 = new C(myStack); ThreadP tp = new ThreadP(p); ThreadC tc1 = new ThreadC(c1); ThreadC tc2 = new ThreadC(c2); ThreadC tc3 = new ThreadC(c3); ThreadC tc4 = new ThreadC(c4); ThreadC tc5 = new ThreadC(c5); tp.start(); tc.start(); } } 运行结果：在某些几率下出现异常IndexOutOfBoundException。分析：p1进行生产后进入wait状态；c1开始消费，消费后进入wait状态，假设此时消费者c2、c3、c4、c5都进入wait状态。p1有开始生产，然后唤醒c2进行消费后又进入wait状态，然后唤醒c3，由于代码中是if结构，从wait中醒来时不会再检查条件，而是直接进行remove操作，这时抛出异常。
这是因为条件改变后没有得到即时的响应，解决这个问题的方法是，将if改为while语句即可；
public class MyStack { private List list = new ArrayList(); //操作栈 synchronized public void push(){ while(list.size() == 1){ this.wait(); } list.add("str"); this.notify(); } synchronized public void pop(){ while(list.size() == 0){ this.wait(); } list.remove(0); this.notify(); } } 运行结果：这次不会抛出异常，但是出现假死情况。分析：因为是while循环，那么消费者在检查条件后，优惠进入wait状态，这是生产者和所有的消费者都进入了wait状态。
解决方法：将notify（）方法改为notifyAll（）方法即可。
public class MyStack { private List list = new ArrayList(); //操作栈synchronized public void push(){ while(list.size() == 1){ this.wait(); } list.add("str"); this.notifyAll(); } synchronized public void pop(){ while(list.size() == 0){ this.wait(); } list.remove(0); this.notifyAll(); } } 运行结果：这次不会抛出异常，页不会出现假死情况。程序会正常运行下去。注明：最后一种while + notifyAll的类型同样适用于多生产者和一消费者，以及多生产者和多消费者这两种情况。
来源：oschina
链接：https://my.oschina.net/u/2518655/blog/632134