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

等待队列

等待队列是一个FIFO的队列，在队列中的每个节点都包含一个线程引用，该线程就是在ConditionObject上的额等待线程。如果一个线程调用了ConditionObject的 await方法，那么该线程将会释放锁、构造成节点加入 等待队列中并进行等待状态。其中等待队列的 基本结构如下：

public class ConditionObject  {
     //队列的首节点
     private transient Node firstWaiter;
     //队列的尾节点
     private transient Node lastWaiter;
     ……
 }

在Object的监视模型上，一个对象只能拥有一个同步队列和等待队列。而在Lock中可以拥有一个同步队列和多个等待 队列。

等待

调用Condition的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);
 }

通知

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

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;
            first.nextWaiter = null;
        } while (!transferForSignal(first) &&
                 (first = firstWaiter) != null);
    }
    final boolean transferForSignal(Node node) {
      
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            return false;
		//调用enq方法，等待对垒中的头结点线程安全地移动到同步队列。当前节点移动到同步队列周，当前线程再使用LockSupport唤醒该节点的线程
        Node p = enq(node);
        int ws = p.waitStatus;
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
            LockSupport.unpark(node.thread);
        return true;
    }

引用：

ConditionObject分析

欢迎关注，一起学习~~