Java 并发编程之 Condition 接口

本文部分摘自《Java 并发编程的艺术》

概述

任意一个 Java 对象，都拥有一个监视器方法，主要包括 wait()、wait(long timeout)、notify() 以及 notifyAll() 方法，这些方法与 synchronized 同步关键字配合，可以实现等待 - 通知模式。Condition 接口也提供了类似 Object 的监视器方法，与 Lock 配合可以实现等待 - 通知模式

Object 的监视器方法与 Condition 接口的对比：

对比项	Object 监视器方法	Condition
前置条件	获取对象的监视器锁	调用 Lock.lock() 获取锁调用 Lock.newCondition() 获取 Condition 对象
调用方法	直接调用如：object.wait()	直接调用如：condition.await()
等待队列个数	一个	多个
当前线程释放锁并进入等待队列	支持	支持
当前线程释放锁并进入等待队列，在等待状态中不响应中断	不支持	支持
当前线程释放锁并进入超时等待状态	支持	支持
当前线程释放锁并进入等待状态到将来的某个时间	不支持	支持
唤醒等待队列中的一个线程	支持	支持
唤醒等待队列中的全部线程	支持	支持

接口示例

Condition 定义了等待 - 通知两种类型的方法，当前线程调用这些方法时，需要提前获取到 Condition 对象关联的锁。Condition 对象是由 Lock 对象（调用 Lock 对象的 newCondition() 方法）创建，换句话说，Condition 是依赖 Lock 对象的

public class ConditionUserCase {

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public void conditionWait() throws InterruptedException {
        lock.lock();
        try {
            condition.await();
        } finally {
            lock.unlock();
        }
    }

    public void conditionSignal() {
        lock.lock();
        try {
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

当调用 await() 方法后，当前线程会释放锁并在此等待，而其他线程调用 Condition 对象的 signal() 方法，通知当前线程后，当前线程才从 await() 方法返回，并且在返回前已经获取了锁

Condition 的部分方法以及描述：

方法名称	描 述
void await() throws InterruptedException	当前线程进入等待状态直到被通知（signal）或中断。
void awaitUninterruptibly()	当前线程进入等待状态直到被通知，该方法不响应中断。
long awaitNanos(long nanosTimeout) throws InterruptedException	当前线程进入等待状态直到被通知、中断或者超时，返回值表示剩余超时时间。
boolean awaitUntil(Date deadline) throws InterruptedException	当前线程进入等待状态直到被通知、中断或者到某个时间。如果没有到指定时间就被通知，方法返回 true，否则，表示到了指定时间，返回 false。
void signal()	唤醒一个等待在 Condition 上的线程，该线程从等待方法返回前必须获得与 Condition 相关联的锁。
void signalAll()	唤醒所有等待在 Condition 上的线程，能够从等待方法返回的线程必须获得与 Condition 相关联的锁。

下面通过一个有界队列的示例来深入理解 Condition 的使用方式

public class BoundedQueue<T> {

    private Object[] items;
    // 添加的下标，删除的下标和数据当前数量
    private int addIndex, removeIndex, count;
    private Lock lock = new ReentrantLock();
    private Condition notEmpty = lock.newCondition();
    private Condition notFull = lock.newCondition();

    public BoundedQueue(int size) {
        items = new Object[size];
    }

    /**
     * 添加一个元素，如果数组满，则添加线程进入等待状态，直到有空位
     */
    public void add(T t) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) {
                notFull.await();
            }
            items[addIndex] = t;
            if (++addIndex == items.length) {
                addIndex = 0;
            }
            ++count;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 由头部删除一个元素，如果数组空，则删除线程进入等待状态，直到有新元素添加
     */
    @SuppressWarnings("unchecked")
    public T remove() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                notEmpty.await();
            }
            Object x = items[removeIndex];
            if (++removeIndex == items.length) {
                removeIndex = 0;
            }
            --count;
            notFull.signal();
            return (T) x;
        } finally {
            lock.unlock();
        }
    }
}

实现分析

ConditionObject 是同步器 AbstractQueuedSynchronizer 的内部类，每个 Condition 对象都包含着一个队列（等待队列），该队列是 Condition 对象实现等待 - 通知功能的关键

1. 等待队列

等待队列是一个 FIFO 队列，在队列中的每个节点都包含了一个线程引用，该线程就是在 Condition 对象上等待的线程，如果一个线程调用了 Condition.await() 方法，那么该线程就会释放锁，构造成节点并加入等待队列并进入等待状态

一个 Condition 包含一个等待队列，Condition 拥有首尾节点的引用，新增节点只需要将原有的尾节点 nextWaiter 指向它，并更新尾节点即可。节点引用更新的过程并没有使用 CAS 来保证，原因在于调用 await() 方法的线程必定是获取了锁的线程，也就是该过程是由锁来保证线程安全的

在 Object 的监视器模型上，一个对象拥有一个同步队列和等待队列，而并发包中的 Lock 拥有一个同步队列和多个等待队列，其对应关系如图所示：

2. 等待

调用 Condition 的 await() 方法，会使当前线程进入等待队列并释放锁，同时线程状态变为等待状态。当从 await() 方法返回时，当前线程一定获取了 Condition 相关联的锁

Condition 的 await() 方法如下所示：

public final void await() throws InterruptedException {
    // 检测线程中断状态
    if (Thread.interrupted())
        throw new InterruptedException();
    // 当前线程包装为 Node 并加入等待队列
    Node node = addConditionWaiter();
    // 释放同步状态，也就是释放锁
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    // 检测该节点是否在同步队列中，如果不在，则继续等待
    while (!isOnSyncQueue(node)) {
        // 挂起线程
        LockSupport.park(this);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    // 竞争同步状态
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    // 清理条件队列中的不是在等待条件的节点
    if (node.nextWaiter != null)
        unlinkCancelledWaiters();
    // 对等待线程中断，会抛出异常
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

3. 通知

调用 Condition 的 signal() 方法，将会唤醒在等待队列中等待时间最长的节点（首节点），在唤醒节点之前，会将节点移到同步队列中

Condition 的 signal() 方法代码如下所示：

public final void signal() {
    // 检查当前线程是否获取了锁
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    // 获取等待队列首节点，移动到同步队列并唤醒
    Node first = firstWaiter;
    if (first != null)
        doSignal(first);
}

Condition 的 signAll() 方法，相当于对等待队列中的每个结点均执行一个 signal() 方法，效果就是将等待队列中所有节点全部移动到同步队列中，并唤醒每个节点的线程