前言
关于wait/notify/notifyall有2个经典的面试：
- notify和notifyall有什么区别？
- 为什么wait方法要写在while循环里面而不是if呢？
带着这2个问题，我们来学习下synchronized提供的等待通知机制。
1、你要知道的基本知识
- wait/notify/notifyall都是存在与Object类里面的方法。
ps：为什么要存在Object里面而不是Thread里面呢？赶紧看下这篇吧（<u>大彻大悟synchronized原理，锁的升级</u>），从底层了解其原因。
- wait方法：wait方法只是无参和带超时时间2种方法，调用wait方法的的线程会进入waiting或timed_waiting状态；
- notify方法：调用notify方法的线程，会唤醒一个处于waiting状态的线程；
- notifyall方法：调用notify方法的线程，会唤醒所有处于waiting状态的线程；
有一个前提，就是wait/notify/notifyall方法必须在获取到synchronized资源锁的情况下，才能调用，也就是wait/notify/notifyall必须在synchronized代码块里面。
使用wait/notify/notifyal有个经典的范式，这便是上面的第二个问题。
while(条件不满足) {
wait();
}
2、典型的生产者消费者模式的样例
现在我们写个典型的生产者消费者模式的样例：
- 有2个生产者，当list不满的情况下，往list里面添加数据，当list满的情况下调用wait方法。每添加一条数据，就调用notifyAll()方法。
- 2个消费者，当list不为空的情况下，消费list里面的第一个元素，并且调用notifyAll()方法。
- 为了效果，我让每个生产者只生产了3条数据，消费者一直在消费，最终都进入waiting状态。
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
public class WaitNotifyTest {
private List<String> list = new ArrayList<>();
public static void main(String[] args) {
WaitNotifyTest waitNotifyTest = new WaitNotifyTest();
Thread producer1 = new Thread(() -> {
for (int i = 0; i < 3; i++) {
waitNotifyTest.produce();
}
});
producer1.setName("生产者1号");
Thread producer2 = new Thread(() -> {
for (int i = 0; i < 3; i++) {
waitNotifyTest.produce();
}
});
producer2.setName("生产者2号");
Thread consumer1 = new Thread(() -> {
while (true) waitNotifyTest.consume();
});
consumer1.setName("消费者1号");
Thread consumer2 = new Thread(() -> {
while (true) waitNotifyTest.consume();
});
consumer2.setName("消费者2号");
producer1.start();
producer2.start();
consumer1.start();
consumer2.start();
}
private void produce() {
synchronized (this) {
while (listIsFull()) {
try {
System.out.println(Thread.currentThread().getName() + "进入等待池");
wait();
System.out.println(Thread.currentThread().getName() + "被唤醒了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
String value = UUID.randomUUID().toString();
System.out.println(Thread.currentThread().getName() + "生产了一条消息:" + value);
list.add(value);
notifyAll();
}
}
private void consume() {
synchronized (this) {
while (listIsEmpty()) {
try {
System.out.println(Thread.currentThread().getName() + "进入等待池");
wait();
System.out.println(Thread.currentThread().getName() + "被唤醒了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "消费了一条消息:" + list.get(0));
list.remove(0);
notifyAll();
}
}
private boolean listIsFull() {
return list.size() == 1;
}
private boolean listIsEmpty() {
return list.size() == 0;
}
}
执行结果：
生产者1号生产了一条消息:85158920-3784-4c5f-9c2a-2961aea75086
消费者2号消费了一条消息:85158920-3784-4c5f-9c2a-2961aea75086
消费者2号进入等待池
生产者2号生产了一条消息:3caf8352-28d3-44f6-8a7f-5ecf7356e903
生产者2号进入等待池
消费者1号消费了一条消息:3caf8352-28d3-44f6-8a7f-5ecf7356e903
消费者1号进入等待池
生产者2号被唤醒了
生产者2号生产了一条消息:b8764c83-8b42-4527-a953-4424e1103111
生产者2号进入等待池
消费者2号被唤醒了
消费者2号消费了一条消息:b8764c83-8b42-4527-a953-4424e1103111
消费者2号进入等待池
生产者1号生产了一条消息:32228e02-d7f1-4866-83c7-d3fcfb6a51b4
生产者1号进入等待池
消费者2号被唤醒了
消费者2号消费了一条消息:32228e02-d7f1-4866-83c7-d3fcfb6a51b4
消费者2号进入等待池
生产者2号被唤醒了
生产者2号生产了一条消息:3af2d730-7bf3-4a26-8a96-f6f3f30fc39a
消费者1号被唤醒了
消费者1号消费了一条消息:3af2d730-7bf3-4a26-8a96-f6f3f30fc39a
消费者1号进入等待池
消费者2号被唤醒了
消费者2号进入等待池
生产者1号被唤醒了
生产者1号生产了一条消息:0867b9ae-de1a-486b-b0b0-e56c6b10a49b
消费者2号被唤醒了
消费者2号消费了一条消息:0867b9ae-de1a-486b-b0b0-e56c6b10a49b
消费者2号进入等待池
消费者1号被唤醒了
消费者1号进入等待池
3、notify和notifyAll有什么区别
最简单的回答就是：notify只唤醒一个waiting状态的线程，notifyAll唤醒所有waiting状态的线程。
但是要彻底弄清楚它们的区别，还是要从synchronized的底层说起。看过这篇文章的显然已经知道答案了。
[图片上传失败...(image-2d12eb-1605322860624)]
我这里再整理下。
- synchronized维护的对象锁有2个队列，一个_EntryList，一个_WaitSet。
- 加锁时，线程获取到锁进入临界区（_owner），若线程获取不到锁，便加入_EntryList，进入blocked阻塞状态。
- 线程获取到锁后，调用wait方法，被加入_WaitSet队列，进入waiting状态，然后等待唤醒。当线程被唤醒的时候，被唤醒的线程需要再次获取对象锁。
- 唤醒线程，我们可以调用notify和notifyAll方法，notify只是随机的唤醒一个_WaitSet中的线程。notifyAll会唤醒所有处于_WaitSet中的线程。
- 不管唤醒一个线程，还是唤醒多个线程，最终获得对象锁的，只有一个线程。如果_EntryList同时存在竞争锁资源的线程，那么被唤醒的线程还需要和_EntryList中的线程一起竞争锁资源。但是JVM保证最终只会让一个线程获取到锁。
那如果只唤醒一个线程会有什么问题呢？
拿上面的生产者消费者举个例子：
- 当list为空时，消费者consumer1、consumer2都会处于waiting状态
- 生产者producer1和生产者producer2竞争锁，生产者producer1先拿到锁，生产一条数据，调用notify(假设唤醒的是消费者consumer1），然后producer1进入阻塞blocked状态，并释放锁；
- 消费者consumer1被唤醒后，有三个线程同时竞争锁（producer1、producer2、consumer1），假设producer2获得锁，producer2发现list满了，然后进入waiting状态，并释放锁；
- 锁被释放后，有两个个线程同时竞争锁（producer1、consumer1），假设consumer1获取到锁，consumer1消费消息，然后调用notify（此时consumer2和生产者producer2处于waiting）；
问题就出在这里：
假设唤醒的是生产者producer2，没有问题；
假设唤醒的是消费者consumer2，那consumer2会发现list任然为空，继续进入waiting状态。但是呢，恰好之前进入阻塞状态的producer1已经下线（在这个例子中就是生产了3条数据）。这样就出现了死锁了(producer2和consumer2都处于waiting状态，消费者consumer1在获取到锁后也会进入wait状态）
所以说，使用notify某些希望被唤醒的线程，永远得不到唤醒，获取不到锁资源，导致死锁。
综上所述：我们尽量使用notifyAll而不是notify。除非你经过深思熟虑，且明确知道唤醒的就你希望的线程（比如上例中只有一个生产者一个消费者）
4、为什么wait方法要写在while循环里面而不是if呢
再来看下第二个问题：为什么wait方法要写在while循环里面而不是if呢？
private void produce() {
synchronized (this) {
while (listIsFull()) {
try {
System.out.println(Thread.currentThread().getName() + "进入等待池");
wait();
System.out.println(Thread.currentThread().getName() + "被唤醒了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
String value = UUID.randomUUID().toString();
System.out.println(Thread.currentThread().getName() + "生产了一条消息:" + value);
list.add(value);
notifyAll();
}
}
明确这2点：
- 线程被唤醒之后，代码是紧接着执行wait后面的代码(从上面的执行结果可以看出）；
- 进入waiting状态的线程被唤醒的条件是“条件满足”，对应到下面的例子就是队列不满。
被唤醒的线程需要和其他线程竞争锁资源(最终只有一个线程获取到），那么当被唤醒的线程获得锁资源的时候，之前的条件可能又不满足了。
如果while改成if，那么被唤醒的线程继续执行（默认条件任然满足），这明显会导致并发问题，比如超额生产、消费。
5、总结
以后遇到同样的问题知道怎么回答了吧！
ps：一天一个IDEA小技巧
快捷键[Alt+7]可以打开当前类的架构图（Structure），可以快速查看类、方法、字段等。这样可以提升工作效率哦，不要用鼠标滚动查找啦！！！
例：
image.png
多线程连载:
<u>Java内存模型-volatile的应用（实例讲解)</u>
<u>synchronized的三种应用方式（实例讲解）</u>
<u>可重入锁-synchronized是可重入锁吗？</u>
<u>大彻大悟synchronized原理，锁的升级</u>
<u>一文弄懂Java的线程池</u>
<u>公平锁和非公平锁-ReentrantLock是如何实现公平、非公平的</u>
<u>一图全面了解Java线程的生命周期</u>
<u>守护线程和用户线程的真正区别（实例讲解)</u>
网友评论