详解生产者消费者问题waitnotify附生产者唤醒生产者程序运行不下去的问题

生产者和消费者是线程间进行通信的典型例子。实质是多线程共同操作一缓冲队列。

Synchronized &＃43; wait() notify() 实现&＃xff0c;引出一个问题

• notify只负责唤醒所在对象的阻塞线程中的一个。被唤醒的线程进入可运行状态&＃xff0c;等待cpu时间片。

• notifyAll负责唤醒所在对象的所有阻塞线程&＃xff0c;即所有因为对象阻塞的线程处于唤醒状态&＃xff0c;其中一个线程会获得锁&＃xff0c;当该线程退出后&＃xff0c;其他线程继续竞争。

• 如果用notify()只唤醒一个的话&＃xff0c;程序会执行不下去。这种情况不是死锁。是对象调用wait()方法后&＃xff0c;线程进入等待队列&＃xff0c;如果不唤醒&＃xff0c;不能自己唤醒。这里涉及到线程状态和wait(),notify()方法。

下面详细讲解下wait()和notify()方法。

1. wait()方法

   1. 和notify()一样都不是线程的方法&＃xff0c;在Object超类中就有该方法&＃xff0c;所有的实现类都继承自Object&＃xff0c;所以他们会重写该方法。所以代码中的this.wait()属于Buffer的实现类buffer&＃xff0c;它是多线程共享的类的方法。所以wait(),notify()的前提是获得对象的锁&＃xff0c;即在同步块内使用。
   2. 执行wait()后当前线程进入等待队列&＃xff0c;等待被唤醒&＃xff0c;唤醒方法可以是notify和notifyAll。唤醒后的线程与其他线程一起竞争该对象的锁&＃xff0c;如果获得锁&＃xff0c;从wait()方法后面直接运行&＃xff0c;这里会做代码实现&＃xff0c;清下下面代码的输出&＃xff0c;下面会做分析。执行wait()后当前线程进入等待队列&＃xff0c;等待被唤醒&＃xff0c;唤醒方法可以是notify和notifyAll。唤醒后的线程与其他线程一起竞争该对象的锁&＃xff0c;如果获得锁&＃xff0c;从wait()方法后面直接运行&＃xff0c;这里会做代码实现&＃xff0c;清下下面代码的输出&＃xff0c;下面会做分析。

2. notify()方法

   1. 只唤醒该对象等待队列中的一个线程&＃xff0c;随机唤醒。唤醒后执行notify()后面的代码&＃xff0c;出了同步块后即释放锁。锁池中的线程再竞争该锁。其他的等待队列中的线程还是在等待队列。这里与notifyAll有区别。

3. notifyAll()方法

   1. 唤醒所有等待队列中的线程&＃xff0c;进入锁池&＃xff0c;一起竞争该对象。当某一个线程获得锁&＃xff0c;运行完毕后释放锁或&＃xff0c;锁池中的锁还可以继续竞争。

这里有段深入理解写的很好&＃xff0c;我贴出来
http://blog.csdn.net/ns_code/article/details/17225469
深入理解&＃xff1a;
如果线程调用了对象的wait()方法&＃xff0c;那么线程便会处于该对象的等待池中&＃xff0c;等待池中的线程不会去竞争该对象的锁。

当有线程调用了对象的notifyAll()方法(唤醒所有wait线程)或notify()方法(只随机唤醒一个wait线程)&＃xff0c;被唤醒的的线程便会进入该对象的锁池中&＃xff0c;锁池中的线程会去竞争该对象锁。

优先级高的线程竞争到对象锁的概率大&＃xff0c;假若某线程没有竞争到该对象锁&＃xff0c;它还会留在锁池中&＃xff0c;唯有线程再次调用wait&＃xff08;&＃xff09;方法&＃xff0c;它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行&＃xff0c;直到执行完了synchronized代码块&＃xff0c;它会释放掉该对象锁&＃xff0c;这时锁池中的线程会继续竞争该对象锁。

请看下面代码

public class Main{public static void main(String[] arg){Buffer buffer&＃61;new Buffer(5);Producer producer&＃61;new Producer(buffer);Consumer consumer&＃61;new Consumer(buffer);//创建线程执行生产和消费for(int i&＃61;0;i<1;i&＃43;&＃43;){new Thread(producer,"producer-"&＃43;i).start();}for(int i&＃61;0;i<10;i&＃43;&＃43;){new Thread(consumer,"consumer-"&＃43;i).start();}}
}
class Buffer {private int maxSize;private List<Date> storage;Buffer(int size){maxSize&＃61;size;storage&＃61;new LinkedList<>();}//生产方法public synchronized void put() {try {System.out.println("同步块开始运行处");while (storage.size() &＃61;&＃61;maxSize ){//如果队列满了System.out.println("看生产者从哪开始");System.out.print(Thread.currentThread().getName()&＃43;": wait \n");;this.wait();//阻塞线程}storage.add(new Date());System.out.print(Thread.currentThread().getName()&＃43;": put:"&＃43;storage.size()&＃43; "\n");Thread.sleep(1000);this.notify();//唤起线程//this.notifyAll();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}//消费方法public synchronized void take() {try {while (storage.size() &＃61;&＃61;0 ){//如果队列空了System.out.print(Thread.currentThread().getName()&＃43;": wait \n");this.wait();//阻塞线程}Date d&＃61;((LinkedList<Date>)storage).poll();System.out.print(Thread.currentThread().getName()&＃43;": take:"&＃43;storage.size()&＃43; "\n");Thread.sleep(1000);this.notify();//唤起线程//this.notifyAll();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}
}
//生产者
class Producer implements Runnable{private Buffer buffer;Producer(Buffer b){buffer&＃61;b;}&＃64;Overridepublic void run() {while(true){buffer.put();}}
}
//消费者
class Consumer implements Runnable{private Buffer buffer;Consumer(Buffer b){buffer&＃61;b;}&＃64;Overridepublic void run() {while(true){buffer.take();}}
}


输出&＃xff1a;同步块开始运行处
producer-0: put:1
同步块开始运行处
producer-0: put:2
同步块开始运行处
producer-0: put:3
同步块开始运行处
producer-0: put:4
同步块开始运行处
producer-0: put:5
同步块开始运行处
看生产者从哪开始
producer-0: wait
consumer-8: take:4
consumer-8: take:3
consumer-8: take:2
consumer-8: take:1
consumer-8: take:0
consumer-8: wait
consumer-9: wait
consumer-6: wait
consumer-5: wait
consumer-3: wait
consumer-7: wait
consumer-4: wait
consumer-2: wait
consumer-0: wait
consumer-1: wait
producer-0: put:1
同步块开始运行处
producer-0: put:2
同步块开始运行处
producer-0: put:3
同步块开始运行处
producer-0: put:4
同步块开始运行处
producer-0: put:5
同步块开始运行处
看生产者从哪开始
producer-0: wait
consumer-8: take:4
consumer-8: take:3
consumer-8: take:2
consumer-8: take:1
consumer-8: take:0
consumer-8: wait
consumer-7: wait
consumer-1: wait
consumer-0: wait
consumer-2: wait
consumer-4: wait
consumer-3: wait
consumer-5: wait
consumer-6: wait
consumer-9: wait

这是典型的生产者和消费者代码&＃xff0c;这段代码贴的是这个博客的例子&＃xff0c;写的很好。
http://blog.csdn.net/chenchaofuck1/article/details/51592429

但是在执行该代码的时候&＃xff0c;我发现一个问题&＃xff0c;如果用notify()方法&＃xff0c;我有一个线程运行生产者代码&＃xff0c;10个线程运行消费者代码。缓冲区最多是5个产品。
从输出结果如下&＃xff0c;然后程序就不运行了。下面根据输出结果分析下这段代码&＃xff1a;
同步块开始运行处
producer-0: put:1
同步块开始运行处
producer-0: put:2
同步块开始运行处
producer-0: put:3
同步块开始运行处
producer-0: put:4
同步块开始运行处
producer-0: put:5
生产者线程连续5次获得了锁&＃xff0c;因为put()方法嵌套这while循环&＃xff0c;所以生产者线程再制作完了一个对象后会释放锁&＃xff0c;和消费者线程一个竞争。可能之前进入过该对象&＃xff0c;使得该线程获得锁的概率比较高&＃xff0c;这里有待进一步研究&＃xff01;

同步块开始运行处
看生产者从哪开始
producer-0: wait
第六次进入该对象&＃xff0c;此时已经不能生产了&＃xff0c;运行wait()方法&＃xff0c;进入等待队列&＃xff0c;注意此时等待队列只有一个生产者线程。消费者线程都在锁池中。
此时消费者线程竞争该对象&＃xff0c;消费者线程8获得该对象。注意根据代码&＃xff0c;线程8在第一次消耗产品的时候就执行了notify方法&＃xff0c;此时等待队列的生产者线程已经被唤醒了。一次参与buffer对象的竞争。线程8连续获得锁。

consumer-8: take:4
consumer-8: take:3
consumer-8: take:2
consumer-8: take:1
consumer-8: take:0
consumer-8: wait
都消耗完了&＃xff0c;线程8进入等待队列。此时其他的线程也竞争到了对象锁&＃xff0c;但是没有产品了&＃xff0c;运行wait方法&＃xff0c;进入等待队列。
consumer-9: wait
consumer-6: wait
consumer-5: wait
consumer-3: wait
consumer-7: wait
consumer-4: wait
consumer-2: wait
consumer-0: wait
consumer-1: wait

生产者线程获得锁&＃xff0c;开始加工产品&＃xff0c;没加工一个产品唤醒一个等待队列中的线程。注意下面的此处&＃xff0c;是从producer-0: put:1输出的&＃xff0c;没有输出同步块开始运行处。这证明了被唤醒的线程获得锁后是从wait()返回处开始运行的。

此时连续加工5个产品&＃xff0c;已经有5个线程被唤醒了。
生产者线程执行wait()&＃xff0c;放弃锁。
producer-0: put:1
同步块开始运行处
producer-0: put:2
同步块开始运行处
producer-0: put:3
同步块开始运行处
producer-0: put:4
同步块开始运行处
producer-0: put:5
同步块开始运行处
看生产者从哪开始
producer-0: wait

消费者线程8获得锁&＃xff0c;执行消费任务&＃xff0c; 没消费一次&＃xff0c;运行一次notify方法&＃xff0c;唤醒一个锁。从后面的运行结果来看&＃xff0c;没有唤醒生产者线程。被唤醒的消费者线程竞争锁&＃xff0c;因为没有产品&＃xff0c;执行wait()方法&＃xff0c;然后所有的线程都在等待队列了。
consumer-8: take:4
consumer-8: take:3
consumer-8: take:2
consumer-8: take:1
consumer-8: take:0
consumer-8: wait
consumer-7: wait
consumer-1: wait
consumer-0: wait
consumer-2: wait
consumer-4: wait
consumer-3: wait
consumer-5: wait
consumer-6: wait
consumer-9: wait

这里比较凑巧&＃xff0c;我选了生产5个产品&＃xff0c;有10个消费者线程。如果有10个产品&＃xff0c;10个消费者线程&＃xff0c;生产产品能唤醒10个线程&＃xff0c;消耗产品能唤醒10个线程&＃xff0c;就不会出现上面的问题了&＃xff0c;因为肯定能把所有的线程都唤醒。
如果我设置只生产3个产品&＃xff0c;有10个消费者线程&＃xff0c;后面就不会这么巧&＃xff0c;所有的消费者线程都竞争了一次锁了。输出如下&＃xff1a;
同步块开始运行处
producer-0: put:1
同步块开始运行处
producer-0: put:2
同步块开始运行处
producer-0: put:3
同步块开始运行处
看生产者从哪开始
producer-0: wait
consumer-9: take:2
consumer-9: take:1
consumer-9: take:0
consumer-9: wait
consumer-8: wait
consumer-7: wait
consumer-6: wait
consumer-4: wait
consumer-5: wait
consumer-3: wait
consumer-2: wait
consumer-1: wait
consumer-0: wait
producer-0: put:1
同步块开始运行处
producer-0: put:2
同步块开始运行处
producer-0: put:3
同步块开始运行处
看生产者从哪开始
producer-0: wait
consumer-9: take:2
consumer-9: take:1
consumer-9: take:0
consumer-9: wait
consumer-6: wait
consumer-5: wait
consumer-4: wait
consumer-7: wait
consumer-8: wait

以上用notifyAll不用考虑生产者唤醒生产者&＃xff0c;消费者唤醒消费者的问题了。