前言

关于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>