Java多线程与高并发专题——Condition 和 wait/notify的关系

引入

上一篇关于Condition，我们对Condition有了进一步了解，在之前生产/消费者模式一文，我们讲过如何用 Condition 和 wait/notify 来实现生产者/消费者模式，其中的精髓就在于用Condition 和 wait/notify 来实现简易版阻塞队列，我们先来分别回顾一下这两段代码。

用 Condition 实现简易版阻塞队列

代码如下所示：

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 一个使用 Condition 实现的阻塞队列类。
 * 该类提供了一个线程安全的队列，支持在队列满时阻塞插入操作，
 * 在队列空时阻塞移除操作。
 */
public class MyBlockingQueueForCondition {
    // 存储元素的队列
    private Queue queue;
    // 队列的最大容量
    private int max = 16;
    // 用于线程同步的可重入锁
    private ReentrantLock lock = new ReentrantLock();
    // 当队列不为空时的条件
    private Condition notEmpty = lock.newCondition();
    // 当队列不为满时的条件
    private Condition notFull = lock.newCondition();

    /**
     * 构造函数，初始化队列的最大容量。
     * 
     * @param size 队列的最大容量
     */
    public MyBlockingQueueForCondition(int size){
        this.max = size;
        queue = new LinkedList();
    }

    /**
     * 向队列中插入一个元素。
     * 如果队列已满，线程将被阻塞，直到队列有空间。
     * 
     * @param o 要插入的元素
     * @throws InterruptedException 如果线程在等待时被中断
     */
    public void put(Object o) throws InterruptedException {
        // 获取锁
        lock.lock();
        try {
            // 当队列已满时，线程等待
            while (queue.size() == max) {
                notFull.await();
            }
            // 向队列中添加元素
            queue.add(o);
            // 通知所有等待队列不为空的线程
            notEmpty.signalAll();
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

    /**
     * 从队列中移除并返回一个元素。
     * 如果队列为空，线程将被阻塞，直到队列中有元素。
     * 
     * @return 队列中的第一个元素
     * @throws InterruptedException 如果线程在等待时被中断
     */
    public Object take() throws InterruptedException {
        // 获取锁
        lock.lock();
        try {
            // 当队列为空时，线程等待
            while (queue.size() == 0) {
                notEmpty.await();
            }
            // 从队列中移除并获取元素
            Object item = queue.remove();
            // 通知所有等待队列不为满的线程
            notFull.signalAll();
            return item;
        } finally {
            // 释放锁
            lock.unlock();
        }
    }
}

在上面的代码中，首先定义了一个队列变量 queue，其最大容量是 16；然后定义了一个ReentrantLock 类型的 Lock 锁，并在 Lock 锁的基础上创建了两个 Condition，一个是 notEmpty，另一个是 notFull，分别代表队列没有空和没有满的条件；最后，声明了 put 和 take 这两个核心方法。

用 wait/notify 实现简易版阻塞队列

我们再来看看如何使用 wait/notify 来实现简易版阻塞队列，代码如下：

import java.util.LinkedList;
/**
 * 自定义阻塞队列类，使用 wait() 和 notifyAll() 方法实现线程同步。
 */
public class MyBlockingQueueForWaitNotify {
    /**
     * 队列的最大容量
     */
    private int maxSize;
    /**
     * 存储队列元素的链表
     */
    private LinkedList<Object> storage;

    /**
     * 构造函数，初始化队列的最大容量和存储链表。
     *
     * @param size 队列的最大容量
     */
    public MyBlockingQueueForWaitNotify (int size) {
        // 将传入的最大容量赋值给类的成员变量
        this.maxSize = size;
        // 初始化存储链表
        storage = new LinkedList<>();
    }

    /**
     * 向队列中添加一个元素。如果队列已满，则线程进入等待状态。
     *
     * @throws InterruptedException 如果线程在等待过程中被中断
     */
    public synchronized void put() throws InterruptedException {
        // 当队列已满时，当前线程进入等待状态
        while (storage.size() == maxSize) {
            this.wait();
        }
        // 向队列中添加一个新元素
        storage.add(new Object());
        // 唤醒所有等待的线程
        this.notifyAll();
    }

    /**
     * 从队列中取出一个元素。如果队列为空，则线程进入等待状态。
     *
     * @throws InterruptedException 如果线程在等待过程中被中断
     */
    public synchronized void take() throws InterruptedException {
        // 当队列为空时，当前线程进入等待状态
        while (storage.size() == 0) {
            this.wait();
        }
        // 从队列中移除并打印第一个元素
        System.out.println(storage.remove());
        // 唤醒所有等待的线程
        this.notifyAll();
    }
}

如代码所示，最主要的部分仍是 put 与 take 方法。我们先来看 put 方法，该方法被 synchronized 保护，while 检查 List 是否已满，如果不满就往里面放入数据，并通过 notifyAll() 唤醒其他线程。同样，take 方法也被 synchronized 修饰，while 检查 List 是否为空，如果不为空则获取数据并唤醒其他线程。

在生产/消费者模式中，有对这两段代码的详细讲解，遗忘的小伙伴可以到前面复习一下。

Condition 和 wait/notify的关系

对比上面两种实现方式的 put 方法，会发现非常类似，此时让我们把这两段代码同时列在屏幕中，然后进行对比：

public void put(Object o) throws InterruptedException {
    lock.lock();
    try {
        while (queue.size() == max) {
            notFull.await();
        }
        queue.add(o);
        notEmpty.signalAll();
    } finally {
        lock.unlock();
    }
}

public synchronized void put() throws InterruptedException {
    while (storage.size() == maxSize) {
        this.wait();
    }
    storage.add(new Object());
    this.notifyAll();
}

可以看出，左侧是 Condition 的实现，右侧是 wait/notify 的实现：

lock.lock() 对应进入 synchronized 方法
condition.await() 对应 object.wait()
condition.signalAll() 对应 object.notifyAll()
lock.unlock() 对应退出 synchronized 方法

实际上，如果说 Lock 是用来代替 synchronized 的，那么 Condition 就是用来代替相对应的 Object 的wait/notify/notifyAll，所以在用法和性质上几乎都一样。

Condition 把 Object 的 wait/notify/notifyAll 转化为了一种相应的对象，其实现的效果基本一样，但是把更复杂的用法，变成了更直观可控的对象方法，是一种升级。

await 方法会自动释放持有的 Lock 锁，和 Object 的 wait 一样，不需要自己手动释放锁。

另外，调用 await 的时候必须持有锁，否则会抛出异常，这一点和 Object 的 wait 一样。

总结

Condition 是对 wait/notify 的改进和扩展，提供了更高的灵活性和可读性。如果需要更复杂的线程通信机制，建议使用 Condition；如果场景简单，可以继续使用 wait/notify。

下面我们梳理总结一下，核心异同，以及各自适用场景：

相似点

目的相同：两者都是用于实现线程间的通信和同步。它们允许一个线程等待某个条件满足，然后由另一个线程通知它条件已经满足，从而继续执行。

等待和通知机制：都涉及线程进入等待状态，然后被其他线程通知唤醒。在等待期间，线程会释放锁，以便其他线程可以进入同步块修改共享状态。

线程通信：两者都用于线程间的通信，允许线程等待或唤醒其他线程。

需要锁：两者都需要与锁配合使用，wait/notify 依赖 synchronized，而 Condition 依赖 Lock。

不同点

特性	`wait/notify`	`Condition`
锁的管理	隐式锁（通过 synchronized）	显式锁（通过 Lock）
灵活性	较低，只能有一个等待队列	较高，可以有多个条件变量（多个等待队列）
可读性	较低，代码容易变得复杂	较高，代码更清晰
中断处理	不支持中断	支持中断（awaitUninterruptibly() 等）
等待条件	无法指定多个条件	可以指定多个条件（newCondition()）

适用场景

wait/notify：适用于简单的线程通信场景。

在 Java 中，wait、notify和notifyAll是Object类的方法。当一个线程调用一个对象的wait方法时，它会进入等待状态，直到另一个线程调用同一个对象的notify或notifyAll方法。通常在使用synchronized关键字实现同步的时候使用。例如，一个线程在同步块中调用wait方法等待某个条件，另一个线程在同步块中改变了这个条件后调用notify或notifyAll方法通知等待的线程。

Condition：适用于复杂的线程通信场景，尤其是需要多个条件变量的场景。

在 Java 中，Condition是在java.util.concurrent.locks包下的一个接口，它是对传统的对象监视器方法（如wait、notify和notifyAll）的一种替代，用于更灵活地实现线程间的通信和等待。通常在使用ReentrantLock实现同步的时候，配合Condition来实现线程间的等待和通知。比如，当一个线程需要等待某个条件满足时，它可以调用Condition的await方法进入等待状态，直到另一个线程调用signal或signalAll方法来通知它条件已经满足。