Java中的Condition详解

一、Condition简介

任意一个Java对象，都拥有一组监视器方法（定义在Object类中），主要包括wait，notify，notifyAll方法，这些方法与synchornized关键字相配合，可以实现等待/通知模式。

Condition接口也提供了类似的Object的监视器方法，与Lock配合可以实现等待/通知模式。但是这两者在使用方式以及功能上还是有差别的。

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

Condition在调用方法之前必须获取锁。使用方式如下图

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

Contiditon定义的部分方法如下

 二、Condition的实现分析

Condition的实现，主要包括等待队列，等待和通知。

2.1、等待队列

等待队列是一个FIFO的队列，在队列中的每个节点都包含了一个线程引用，该线程就是在Condition对象上等待的线程，

如果一个线程调用了Condition.await方法，那么该线程将会释放锁，构造成节点并加入等待队列进入等待状态。

一个Condition包含一个等待队列，Condition对象拥有首节点和尾节点的引用。当前线程调用await方法，将会构造节点并加入到等待队列尾部。等待队列的基本结构如图所示。

如图所示，Condition拥有首节点和尾节点的引用，而新增节点只需要将原有的尾节点的nextWaiter指向它，并且更新尾节点即可。上述节点引用更新的过程并没有使用CAS保证，因为调用await的线程必定是获取了锁的线程，也就是说，这个过程是由锁来保证线程安全的。

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

如图所示，Condition的实现是同步器的内部类，因此每个Condition实例都能够访问同步器AQS提供的方法。

2.2、等待

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

如果从队列（同步队列和等待队列）的角度来看await方法，调用await方法时，相当于同步队列的首节点移动到了等待队列中。

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);
        //线程被唤醒后，查看线程是否取消或被中断，如果被取消或被中断，则跳出循环
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    //线程以独占方式获取锁
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

调用await方法的线程成功获取了锁，该方法会将当前线程构造成节点并加入等待队列中，然后释放同步状态，唤醒同步队列中的后继节点。

当等待队列中的节点被唤醒，则唤醒节点的线程开始尝试获取同步状态，如果不是通过其他线程调用singal方法唤醒，而是对线程进行中断，则会抛出中断异常。

同步队列的首节点不会直接加入到等待队列，而是通过addConditionWaiter方法把当前线程构造成一个新的节点并将其加入等待队列。

三、通知

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

public final void signal() {
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    //取出等待队列的首节点
    Node first = firstWaiter;
    if (first != null)
        //唤醒节点
        doSignal(first);
}
private void doSignal(Node first) {
    do {
        //首节点引用后移
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        //将首节点的nextWaiter指针置空
        first.nextWaiter = null;
    } while (!transferForSignal(first) &&
            (first = firstWaiter) != null);
}
final boolean transferForSignal(Node node) {
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;
    //将该节点加入同步队列尾部
    Node p = enq(node);
    int ws = p.waitStatus;
    //如果该节点处于取消或者被中断的状态，或者将该节点的状态以CAS操作设置为SINGAL失败，都会唤醒这个线程
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        LockSupport.unpark(node.thread);
    return true;
}

通过调用AQS的enq方法，等待队列的头结点线程安全的移动到同步队列。当节点移动到同步队列后，当前线程的状态如果处于取消或者被中断的状态，或者更新该节点的状态失败则会唤醒这个线程。

被唤醒后的线程将从await方法的while循环中退出（isOnSyncQueue返回true，因为节点已经在同步队列中），进而调用AQS的acquireQueued方法加入到获取同步状态的竞争中。

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

原文地址: Java中的Condition_yanghan1222的博客-CSDN博客_java的condition