本文通过wait()，notify()，notifyAll()模拟生产者-消费者例子，说明为什么使用notify()会发生死锁。
1.代码示例
1.1 生产者
package com.example.hxk.thread.demo;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* @author Smith 2019/3/21
*/
public class Producer implements Runnable{
List<Integer> cache;
public void put() throws InterruptedException {
synchronized (cache) {
while (cache.size() == 1) {
try {
cache.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
TimeUnit.SECONDS.sleep(1);
cache.add(1);
System.out.println(Thread.currentThread().getName() + "生产者生产了一条。");
cache.notify();
}
}
public Producer(List<Integer> cache) {
this.cache = cache;
}
@Override
public void run() {
while (true) {
try {
put();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
1.2 消费者
package com.example.hxk.thread.demo;
import java.util.List;
/**
* @author Smith 2019/3/21
*/
public class Customer implements Runnable {
List<Integer> cache;
public Customer(List<Integer> cache) {
this.cache = cache;
}
private void custom() {
synchronized (cache) {
while (cache.size() == 0) {
try {
cache.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
cache.remove(0);
System.out.println(Thread.currentThread().getName() + "消费者消费了一条。");
cache.notify();
}
}
@Override
public void run() {
while (true) {
custom();
}
}
}
1.3 测试代码
1.3.1 一个生产者一个消费者
package com.example.hxk.thread.demo;
import java.util.ArrayList;
import java.util.List;
/**
* @author Smith 2019/3/21
*/
public class Test {
public static void main(String[] args) {
List<Integer> cache = new ArrayList<>();
new Thread(new Producer(cache), "P1").start();
new Thread(new Customer(cache), "C1").start();
}
}
运行结果：
结论：
使用notify且一个生产者一个消费者的情况下，生产和消费有条不紊的运行，没有任何问题。
1.3.2 一个生产者两个消费者
package com.example.hxk.thread.demo;
import java.util.ArrayList;
import java.util.List;
/**
* @author Smith 2019/3/21
*/
public class Test {
public static void main(String[] args) {
List<Integer> cache = new ArrayList<>();
new Thread(new Producer(cache), "P1").start();
new Thread(new Customer(cache), "C1").start();
new Thread(new Customer(cache), "C2").start();
}
}
运行结果：
结论：
使用notify且一个生产者两个消费者的情况下，生产了两次后，程序死锁了。
1.3.3 将Producer和Customer中的notify()换成notifyAll()
代码就不粘了。
运行结果
程序又恢复了正常。
2.notify()和notifyAll的区别
每个同步对象都有自己的锁池和等待池。
2.1 锁池和等待池
- 锁池：假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。
- 等待池：假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁(因为wait()方法必须出现在synchronized中，这样自然在执行wait()方法之前线程A就已经拥有了该对象的锁)，同时线程A就进入到了该对象的等待池中。如果另外的一个线程调用了相同对象的notifyAll()方法，那么处于该对象的等待池中的线程就会全部进入该对象的锁池中，准备争夺锁的拥有权。如果另外的一个线程调用了相同对象的notify()方法，那么仅仅有一个处于该对象的等待池中的线程(随机)会进入该对象的锁池.
2.2 notify()和notifyAll()的区别
- 线程调用了wait()方法，便会释放锁，并进入等待池中，不会参与锁的竞争
- 调用notify()后，等待池中的某个线程(只会有一个)会进入该对象的锁池中参与锁的竞争，若竞争成功，获得锁，竞争失败，继续留在锁池中等待下一次锁的竞争。
- 调用notifyAll()后，等待池中的所有线程都会进入该对象的锁池中参与锁的竞争。
3.例子解析
知道了2的知识后，上面的三个例子也就好解释了。
1.3.1：因为只有一个生产者和消费者，所以等待池中始终只有一个线程，要么就是生产者唤醒消费者，要么消费者唤醒生产者，所以程序可以成功跑起来；
1.3.2：举个可能的例子
- 现在有三个线程，生产者P1, 消费者C1和C2.开始运行的时候，三个都在锁池中等待竞争，假设C1抢到锁了，C1执行时由于没有资源可以消费 调用wait()方法，释放锁并进入等待池。
- C2抢到了锁，开始消费，同理，C2也进入了等待池。现在锁池里面只剩下了P1.
- P1获得了锁，开始生产，生产完成后，P1开始调用notify()方法唤醒等待池中的C1或者C2，然后P1调用wait()方法释放锁，并进入了等待池。
- 假设唤醒的是C1，C1进入锁池并获得锁，消费后notify()方法唤醒了C2,C2进入锁池，C1进入等待池，现在锁池中只有C1。
- C1获得了锁，发现没有任何资源可以消费，wait()后释放了锁，进入了等待池，现在三个线程全都在等待池，锁池中没有任何线程。导致死锁！
1.3.3: notifyAll()后，不存在只唤醒同类线程的情况，故也就不会出现1.3.2死锁的情况。
引用
-
作者：emailed 来源：CSDN 原文：blog.csdn.net/emailed/art…
-
作者：泡芙掠夺者 来源：简书 原文：www.jianshu.com/p/45626f4e0…
