【并发基础】Condition详解

简介

Condition通过Lock接口的newCondition方法创建，因此需要在获取到锁之后，才能调用Condition的等待/通知方法，这一点与Object的监视器方法类似。

另一点与Object.wait相似的是，Condition.await方法也会自动释放相关联的锁，并将当前线程挂起。

接口详解

await()

调用await()方法后，Condition相关联的锁会自动释放，当前线程会被挂起并进入休眠状态，该方法会响应中断，以下4种场景可以唤醒线程：

• 其他线程调用该Condition的notify方法，同时当前线程被系统选为唤醒的线程；
• 其他线程调用该Condition的notifyAll方法；
• 其他线程中断当前线程，同时系统支持休眠线程的中断操作；
• 发生虚假唤醒 (spurious wakeup)

awaitUninterruptibly()

调用awaitUninterruptibly()方法后，Condition相关联的锁会自动释放，当前线程会被挂起并进入休眠状态，该方法不响应中断，以下3种场景可以唤醒线程：

• 其他线程调用该Condition的notify方法，同时当前线程被系统选为唤醒的线程；
• 其他线程调用该Condition的notifyAll方法；
• 发生虚假唤醒 (spurious wakeup)

awaitNanos(long nanosTimeout)、await(long time, TimeUnit unit)、awaitUntil(Date deadline)

调用该方法后，当前线程进入等待状态，直到被唤醒、中断或者超时，并且Condition相关联的锁会自动释放。
以下5种场景可以唤醒线程：

• 其他线程调用该Condition的notify方法，同时当前线程被系统选为唤醒的线程；
• 其他线程调用该Condition的notifyAll方法；
• 其他线程中断当前线程，同时支持休眠线程的中断操作；
• 等待超时；
• 发生虚假唤醒 (spurious wakeup)

signal()

调用signal()之后，系统会挑选一个调用过await方法的线程进行唤醒，唤醒的线程需要重新尝试获取锁，才能继续往下执行。

调用signal()方法的线程需要获取到Condition相关联的锁，否则会抛出IllegalMonitorStateException异常。

signalAll()

调用signalAll()方法后，会唤醒所有等待的线程，但是每个线程想要往下执行需要重新获取锁，否则会处于阻塞状态。

ConditionObject实现

ConditionObject是Condition接口的实现类，是AbstractQueuedSynchronizer(即AQS)的一个内部类。ReentrantLock的newCondition方法创建的就是ConditionObject实例，因此我们着重研究下其实现。

数据结构

//等待队列的头结点
private transient Node firstWaiter;
//等待队列的尾结点
private transient Node lastWaiter;
//
private static final int REINTERRUPT =  1;
//
private static final int THROW_IE    = -1;

等待队列是单向链表，指针是nexiWiater，同时具有头尾指针。Node结点的数据结构参见之前的《AQS详解》。

方法详解

await()

await方法会将当前线程结点添加到等待队列中，并释放当前线程获取到的锁，并且阻塞当前线程，当被其他线程唤醒时，当前线程需要重新获取到锁才能继续执行。

public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //添加到等待队列
    Node node = addConditionWaiter();
    //释放当前线程获取的资源
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    
    /**
     * 此处的逻辑为：
     * 第一次循环时，由于结点的waitStatus为CONDITION，因此会进入到while内部代码中，使用LockSupport.park使线程阻塞。
     * 要唤醒线程，基本有两种方式：一种是使用signal()或signalAll()方法唤醒；另一种则是发生中断。
     */
    //判断当前结点是否在同步队列中，当使用signal或signalAll唤醒、或者发生中断，结点都会进入同步队列中，才会跳过while循环，执行后续代码
    while (!isOnSyncQueue(node)) {
        //阻塞当前线程
        LockSupport.park(this);
        //awit方法响应中断，此处判断线程等待过程中是否被中断
        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);
}

/**
 * 检查中断： 
 * 未中断返回0 
 * 被唤醒前中断返回 THROW_IE 
 * 被唤醒后中断返回 REINTERRUPT
 */
private int checkInterruptWhileWaiting(Node node) {
    return Thread.interrupted() ?
        (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) : 0;
}

/**
 * 尝试将节点状态从CONDITION状态置为0
 * 如果设置成功，证明没有调用sign或signAll方法，线程唤醒是因为发生中断，因此将结点加入同步队列，并返回true。
 * 如果设置不成功，则时通过sign或signAll唤醒，返回false
 */
final boolean transferAfterCancelledWait(Node node) {
    //将节点状态从CONDITION状态置为0，设置成功加入同步队列中
    if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
        enq(node);
        return true;
    }
    
    while (!isOnSyncQueue(node))
        Thread.yield();
    return false;
}

/**
 * 如果interruptMode为THROW_IE，即在sign之前发送中断，则抛出InterruptedException。
 * 如果interruptMode为REINTERRUPT，即在sign之后发生中断，则调用interrupt方法，将中断补上。
 */
private void reportInterruptAfterWait(int interruptMode) throws InterruptedException {
    if (interruptMode == THROW_IE)
        throw new InterruptedException();
    else if (interruptMode == REINTERRUPT)
        selfInterrupt();
}

addConditionWaiter()

addConditionWaiter方法将线程结点添加到等待队列的队尾。

private Node addConditionWaiter() {
    Node t = lastWaiter;
    // If lastWaiter is cancelled, clean out.
    if (t != null && t.waitStatus != Node.CONDITION) {
        //将等待队列中等待状态不等于CONDITION的结点从队列中剔除
        unlinkCancelledWaiters();
        t = lastWaiter;
    }
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    if (t == null)
        firstWaiter = node;
    else
        t.nextWaiter = node;
    lastWaiter = node;
    return node;
}

isOnSyncQueue(Node)

isOnSyncQueue方法主要用于判断当前结点是否在同步队列中

final boolean isOnSyncQueue(Node node) {
    if (node.waitStatus == Node.CONDITION || node.prev == null)
        return false;
    // If has successor, it must be on queue
    if (node.next != null) 
        return true;
    return findNodeFromTail(node);
}

private boolean findNodeFromTail(Node node) {
    Node t = tail;
    for (;;) {
        if (t == node)
            return true;
        if (t == null)
            return false;
        t = t.prev;
    }
}

unlinkCancelledWaiters()

unlinkCancelledWaiters方法主要将等待队列中等待状态不等于CONDITION的结点从队列中剔除。

private void unlinkCancelledWaiters() {
    //头结点
    Node t = firstWaiter;
    Node trail = null;
    while (t != null) {
        Node next = t.nextWaiter;
        if (t.waitStatus != Node.CONDITION) {
            t.nextWaiter = null;
            if (trail == null)
                firstWaiter = next;
            else
                trail.nextWaiter = next;
            if (next == null)
                lastWaiter = trail;
        }
        else
            trail = t;
        t = next;
    }
}

fullyRelease(Node)

fullyRelease方法释放当前线程结点的资源，因为ReentrantLock只有一个资源，因此ReentrantLock创建的Condition的await方法相当于释放锁。

final int fullyRelease(Node node) {
    boolean failed = true;
    try {
        int savedState = getState();
        if (release(savedState)) {
            failed = false;
            return savedState;
        } else {
            throw new IllegalMonitorStateException();
        }
    } finally {
        if (failed)
            node.waitStatus = Node.CANCELLED;
    }
}

signal()

signal方法只唤醒等待队列的头结点，并将头结点出队列，加到同步队列队尾。
signal方法需要获取锁才能调用，否则抛出IllegalMonitorStateException异常。

public final void signal() {
    //该方法由子类实现，例如ReentrantLock
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    //只唤醒等待队列的头结点
    Node first = firstWaiter;
    if (first != null)
        doSignal(first);
}

doSignal(Node)

private void doSignal(Node first) {
    do {
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        //头结点出condition队列  
        first.nextWaiter = null;
    } while (!transferForSignal(first) && (first = firstWaiter) != null);
}

final boolean transferForSignal(Node node) {
    //将结点状态重置为0
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;

    //将当前结点加入同步队列
    Node p = enq(node);
    int ws = p.waitStatus;
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        LockSupport.unpark(node.thread);
    return true;
}

signalAll()

signalAll方法会清空condition队列，并将condition队列中所有的结点都加入到同步队列中。
signalAll方法需要获取锁才能调用，否则抛出IllegalMonitorStateException异常。

public final void signalAll() {
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    Node first = firstWaiter;
    if (first != null)
        doSignalAll(first);
}

doSignalAll(Node)

private void doSignalAll(Node first) {
    lastWaiter = firstWaiter = null;
    do {
        Node next = first.nextWaiter;
        first.nextWaiter = null;
        transferForSignal(first);
        first = next;
    } while (first != null);
}