ConditionObject源码分析

　　ConditionObject是AbstractQueuedSynchronizer(AQS)实现的内部类，类图如下：

 

1、Condition接口

　　ConditionObject实现了Condition接口。先来看看Codition接口。

 

　　Codition中主要定义了挂起线程和唤醒线程的接口方法。Condition接口详情如下：

public interface Condition {
    
    /**
     * 自动释放锁资源
     * 挂起当前线程，通过方法signal/signalAll、或线程中断，唤醒挂起线程
     */
    void await() throws InterruptedException;

    /**
     * 自动释放锁资源
     * 挂起当前线程，通过方法signal/signalAll、或虚假唤醒，唤醒挂起线程
     */
    void awaitUninterruptibly();

    /**
     * 自动释放锁资源
     * 挂起当前线程，通过方法signal/signalAll、或线程中断、或挂起时间(纳秒)已到达、或虚假唤醒的方式，唤醒挂起线程
     */
    long awaitNanos(long nanosTimeout) throws InterruptedException;

    /**
     * 自动释放锁资源
     * 挂起当前线程，通过方法signal/signalAll、或线程中断、或挂起时间已到达，唤醒挂起线程
     */
    boolean await(long time, TimeUnit unit) throws InterruptedException;

    /**
     * 自动释放锁资源
     * 挂起当前线程，通过方法signal/signalAll、或线程中断、或挂起时间已到达，唤醒挂起线程
     */
    boolean awaitUntil(Date deadline) throws InterruptedException;

    /**
     * 唤醒一个挂起的线程
     */
    void signal();

    /**
     * 唤醒所有挂起的线程
     */
    void signalAll();
}

2、ConditionObject的使用

　　ConditionObject使用详情如下：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class TestConditionObject {

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        // 子线程
        new Thread(() -> {
            // 子线程加锁
            lock.lock();
            System.out.printf("子线程【%s】获取锁", Thread.currentThread().getName());
            // 休眠3s
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 挂起当前子线程，并释放锁资源
            try {
                 System.out.printf("子线程【%s】挂起，并释放锁资源", Thread.currentThread().getName());
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.printf("子线程【%s】执行结束，并释放锁资源", Thread.currentThread().getName());
        }).start();

        // 休眠100ms
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 主线程获得锁，挂起子线程
        lock.lock();
        System.out.println("主线程拿到锁资源，子线程已执行await方法");
        condition.signal();
        System.out.println("主线程唤醒了await挂起的子线程");
        lock.unlock();
    }
}

　　通过上述代码执行结果，可推出线程执行示意图如下：

  

 　　JDK1.5提供的ArrayBlockingQueue源码中的put(E)和take()方法有对ConditionObject的具体的应用。

通过上述示意图可推导出如下结论：

　　1、await() 会自动释放锁资源，因为main线程可以获取锁资源

　　2、唤醒的线程通过 await() 会获取锁资源，因为await()在释放锁资源之后， 重新获取到锁，后续的unlock()才有意义。

如此，可以将await()方法分成两部分，挂起线程的部分，被唤醒后的部分，流程：await() -> signal() -> await()，下面通过源码来验证我们的推论：

3、ConditionObject源码分析

　　ConditionObject的属性信息：

// condition队列中的头节点
private transient Node firstWaiter;
// condition队列中的尾节点
private transient Node lastWaiter;

　　挂起线程、唤醒线程整体流程：

  

3.1、ConditionObject的初始化

　　ConditionObject是在Lock接口提供的newCondition()方法完成初始化的。以ReentrantLock为例，ReentrantLock#newCondition()详情如下：

// 抽象队列同步器
private final Sync sync;

// 创建ConditionObject对象
public Condition newCondition() {
    return sync.newCondition();
}

　　Sync#newCondition()详情如下：

final ConditionObject newCondition() {
    return new ConditionObject();
}

　　通过初始化方法可以得出结论：一个lock锁中可以有多个Condition对象。且当某个Condition进行操作时，不会影响其他Condition。

3.2、await() - 挂起线程前奏

1、await()挂起线程前奏流程

 

2、await()挂起线程前奏源码分析

　　AbstractQueuedSynchronizer#ConditionObject#await() 详情如下：

// 线程中断，挂起线程退出
private static final int REINTERRUPT =  1;
/** Mode meaning to throw InterruptedException on exit from wait */
// 抛出异常，挂起线程退出
private static final int THROW_IE    = -1;

public final void await() throws InterruptedException {
    // 当前线程已中断，抛异常
    if (Thread.interrupted())
        throw new InterruptedException();
    // 将当前线程封装成Node，并添加到Condition链表
    Node node = addConditionWaiter();
    // 释放全部锁资源，并保存线程重入次数
    int savedState = fullyRelease(node);
    // 线程中断模式
    int interruptMode = 0;
    // 判断当前Node是否在AQS队列中，在fullyRelease方法时释放了全部说资源，若当前线程刚释放锁资源，
    // 其他线程就执行了signal方法，此时当前线程会被方法哦AQS的队列中，线程不需要再执行LockSupport.park(this);挂起线程
    while (!isOnSyncQueue(node)) {
        // 若没有在AQS队列中，在Condition单向链表里，挂起线程。
        LockSupport.park(this);
        
        // ...
    }
    // ...
}

　　添加需要挂起的线程，AbstractQueuedSynchronizer#addConditionWaiter() 详情如下：

// 在condition单向链表中添加需要挂起的线程
private Node addConditionWaiter() {
    // 获取尾节点
    Node t = lastWaiter;
    // 如果队列尾节点的状态不为 -2，将尾节点从队列移除
    if (t != null && t.waitStatus != Node.CONDITION) {
        unlinkCancelledWaiters();
        // 获取最新的尾节点
        t = lastWaiter;
    }
    // 将当前线程封装为Node，设置状态为-2
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    // 尾节点为null
    if (t == null)
        // 当前节点设置为头节点
        firstWaiter = node;
    else
        // 将当前节点设置在lastWaiter的后面
        t.nextWaiter = node;
    // 当前节点设置为的尾节点
    lastWaiter = node;
    // 返回当前节点
    return node;
}

　　移除需要取消的节点，AbstractQueuedSynchronizer#ConditionObject#unlinkCancelledWaiters() 详情如下：

// 移链表中被取消的节点
private void unlinkCancelledWaiters() {
    // 获取头节点
    Node t = firstWaiter;
    Node trail = null;
    // t不为null
    while (t != null) {
        // 获取t的下一节点
        Node next = t.nextWaiter;
        // t节点状态不为-2，需被移除
        if (t.waitStatus != Node.CONDITION) {
            // t节点的下一节点设置为null
            t.nextWaiter = null;
            // trail为null，说明t是头节点，首次进入循环
            if (trail == null)
                // 将头节点执行next节点
                firstWaiter = next;
            else
                // trail有值，表示不是头节点位置，将t的上一节点指向t的下一节点
                trail.nextWaiter = next;
            // 如果next为null，说明单向链表遍历结束
            if (next == null)
                // 将trail作为链表尾节点
                lastWaiter = trail;
        }
        // t的状态为-2
        else
            // 将t赋值给局部变量trail
            trail = t;
        // t指向它的下一节点
        t = next;
    }
}

　　释放锁资源，AbstractQueuedSynchronizer#ConditionObject#fullyRelease() 详情如下：

// 释放锁资源
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;
    }
}

　　此处验证了前面的推导，执行await()方法会释放锁资源，同时保存重入次数，方便在获取锁时初始化重入次数。

　　当前节点是否在AQS队列中，AbstractQueuedSynchronizer#isOnSyncQueue() 详情如下：

// 判断当前线程节点是否在AQS队列中
final boolean isOnSyncQueue(Node node) {
    // 线程节点状态为 -2，表示在condition单向链表中，未在AQS队列
    // prev节点值为null，未在AQS队列中
    if (node.waitStatus == Node.CONDITION || node.prev == null)
        return false;
    // 当前线程节点的next不为null，表示在AQS队列中  ？？？
    if (node.next != null) 
        return true;
    
    // 在AQS队列中寻找当前线程节点
    return findNodeFromTail(node);
}

　　在AQS队列中寻找当前线程节点，AbstractQueuedSynchronizer#findNodeFromTail() 详情如下：

// 在AQS队列中寻找当前线程节点
private boolean findNodeFromTail(Node node) {
    // 获取AQS队尾节点
    Node t = tail;
    for (;;) {
        // 当前线程节点在AQS队列中存在
        if (t == node)
            // 返回true
            return true;
        // 遍历结束，AQS队列中没有此节点
        if (t == null)
            // 返回false
            return false;
        // t的上一节点，继续遍历
        t = t.prev;
    }
}

3.3、signal() - 唤醒线程

1、signal() 唤醒线程流程

  

2、signal() 唤醒线程源码分析

　　AbstractQueuedSynchronizer#ConditionObject#signal() 详情如下：

// 唤醒线程
public final void signal() {
    // 当前线程没有持有锁资源，抛出异常
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    // 获取condition单向链表中的头节点
    Node first = firstWaiter;
    // 头节点不为空，有Node节点在等待
    if (first != null)
        // 唤醒头节点
        doSignal(first);
}

　　AbstractQueuedSynchronizer#ConditionObject#doSignal() 详情如下：

// 唤醒Condition中的Node中的线程
private void doSignal(Node first) {
    do {
        // 获取第二个节点，并将第二个节点设置为头节点
        // 若condition队列中就一个节点，则将队列的首、尾节点设置为null
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        // 若condition队列中不止一个节点,还有nextWaiter节点，由于当前节点要被唤醒了，从Condition队列移走
        // 需要将当前节点的nextWaiter置位null
        first.nextWaiter = null;
    // 将condition队列中的节点移动到AQS队列中
    } while (!transferForSignal(first) &&
             // 如果first后还有节点，继续唤醒，如果没有，退出while循环
             (first = firstWaiter) != null);
}

　　AbstractQueuedSynchronizer#transferForSignal 详情如下：

// 唤醒在condition中排队的Node
final boolean transferForSignal(Node node) {
    
    // 将在Condition队列中的Node的状态从-2，改为0，代表要扔到AQS队列了。
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        // CAS失败了，说明在signal之前线程被中断了，从而被唤醒了
        return false;

    // 如果正常的将Node的状态从-2改为0，表示要将Condition中的Node扔到AQS的队列了。
    // 将当前Node扔到AQS队列，返回的p是当前Node的prev
    Node p = enq(node);
    // 获取当前Node上一个Node的状态
    int ws = p.waitStatus;
    // 若ws > 0 ，说明这个Node已经被取消了。
    // 若ws状态不是取消，将prev节点的状态改为-1,。
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        // 1、ws > 0 ，prev节点被取消了
        // 2、prev节点状态正常，但CAS更新prev节点失败
        // 上述两种场景，可能导致当前节点无法被唤醒。JDK的处理是：立即唤醒当前节点，基于 await() 中的acquireQueued方法，让当前节点找到一个正常的prev节点，并挂起线程
        LockSupport.unpark(node.thread);
    // 返回true
    return true;
}

3.4、await() - 挂起线程终章

1、await()挂起线程终章流程

  

2、await()挂起线程终章源码分析

　　await() 中线程唤醒后的处理，AbstractQueuedSynchronizer#ConditionObject#await() 详情如下：

// 线程中断，挂起线程退出
private static final int REINTERRUPT =  1;
/** Mode meaning to throw InterruptedException on exit from wait */
// 抛出异常，挂起线程退出
private static final int THROW_IE    = -1;

public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    Node node = addConditionWaiter();
    int savedState = fullyRelease(node);
    // 中断模式
    int interruptMode = 0;
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);
        
         // 如果线程执行到这，说明现在被唤醒了，确定线程以何种方式唤醒
         // 如果线程不是通过signal唤醒，退出循环
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    // Node在AQS队列，尝试在ReentrantLock中获取锁资源

    // acquireQueued方法返回true：代表线程在AQS队列中挂起时，被中断过
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)       
        // REINTERRUPT：表示await不是被中断唤醒，但是后续被中断过
        interruptMode = REINTERRUPT;
    // 如果当前Node还在condition的单向链表中，将当前Node从Condition的单向链表清除
    if (node.nextWaiter != null) 
        unlinkCancelledWaiters();
    // 如果interruptMode是0，说明线程在signal后以及持有锁的过程中，没被中断过，无需处理
    // 如果interruptMode不是0
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

　　判断线程以何种方式唤醒， AbstractQueuedSynchronizer#ConditionObject#checkInterruptWhileWaiting() 详情如下：

/**
 * 判断线程以何种方式唤醒：
 *   0：正常signal唤醒，并且线程未被中断
 *   THROW_IE（-1）：中断唤醒，被interrupt唤醒的
 *   REINTERRUPT（1）：signal唤醒后，线程被中断了
 */
private int checkInterruptWhileWaiting(Node node) {
    return
        // 线程是否被中断过 
        Thread.interrupted() ?
        // 线程被中断过，判断是中断唤醒的，还是signal唤醒后又被中断了
        (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
        // signal唤醒
        0;
}

　　判断线程是中断唤醒还是signal唤醒后被中断，AbstractQueuedSynchronizer#transferAfterCancelledWait()，详情如下：

// 判断线程是中断唤醒的还是被signal唤醒后被线程中断了
final boolean transferAfterCancelledWait(Node node) {
    // CAS 将 Node 状态由 -2 更新为 0 
    if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
        // CAS 成功，说明线程是中断唤醒的，将Node添加进AQS队列中
        // 中断唤醒：未通过signal流程移除condition单向链表的当前线程节点，在AQS队列和condition单向链表中同时存在
        enq(node);
        // 返回中断唤醒处理标识
        return true;
    }
    // signal唤醒的，当前线程还为被放到AQS队列中，等待signal方法将线程节点添加到AQS队列中
    while (!isOnSyncQueue(node))
        // 当前线程节点没在AQS队列上，线程让步，等待一会，直到Node放到AQS队列再处理
        Thread.yield();
    // 返回中断唤醒处理标识
    return false;
}

　　尝试获取锁资源，AbstractQueuedSynchronizer#acquireQueued() 详情如下：

// 尝试获取锁资源
final boolean acquireQueued(final Node node, int arg) {
    // 获取锁资源失败标识
    boolean failed = true;
    try {
        // 线程中断标识
        boolean interrupted = false;
        for (;;) {
            // 获取当前线程节点的前一节点
            final Node p = node.predecessor();
            // 当前线程节点为AQS队列的首个节点，并且尝试获取锁资源成功
            if (p == head && tryAcquire(arg)) {
                // 将当前线程节点设置为AQS队列头节点
                setHead(node);
                // 当前线程节点的next设置为null
                p.next = null;
                // 设置获取锁资源标识
                failed = false;
                // 返回中断标识
                return interrupted;
            }
            // 获取锁资源失败，线程挂起，并在挂起过程中被中断过
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                // 中断标识设置为true
                interrupted = true;
        }
    } finally {
        // 获取锁资源成功，取消试图获取锁资源的当前节点
        if (failed)
            cancelAcquire(node);
    }

　　此处验证了前面的推导，执行await()方法会释放锁资源，当线程被唤醒后，通过之前记录了的锁重入次数重新获取锁资源。

　　线程挂起后，被中断唤醒的处理，AbstractQueuedSynchronizer#ConditionObject#reportInterruptAfterWait() 详情如下：

// 在线程挂起后，被中断唤醒的处理
private void reportInterruptAfterWait(int interruptMode)
    throws InterruptedException {
    // 抛出异常
    if (interruptMode == THROW_IE)
        throw new InterruptedException();
    // 中断处理
    else if (interruptMode == REINTERRUPT)
        selfInterrupt();
}

4、总结

ConditionObject提供了Lock中挂起线程、唤醒线程的方法。

　　await() 将当前线程封装成Node节点，添加到condition队列中，同时释放当前线程持有锁资源，记录重入次数，挂起线程；

　　signal() 唤醒线程，将condition队列中的Node移动到AQS队列中，等待执行；

　　await() 获取在AQS队列中的Node，通过之前记录的锁重入次数，尝试获取锁资源。