ConditionObject源码

如果一个线程调用了Condition.await,调用该方法的线程一定是获取了锁的线程，该方法会构造成节点加入等待队列尾部并进入等待状态，然后释放同步状态，唤醒同步队列中的后继节点，当从await方法返回时，当前线程一定获取了Condition相关联的锁。
如果从队列角度看await方法，调用await方法时，相当于同步队列的首节点(获取了锁的节点)移动到Condition的等待队列中。
当等待队列中的节点被唤醒，则唤醒节点的线程开始尝试获取同步状态，

        public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            // 把当前线程的节点加入到等待队列中
            Node node = addConditionWaiter();
            // 由于调用await()方法的线程是已经获取了锁的，所以在加入到等待队列之后，需要去释放锁，并且唤醒后继节点线程
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            // isOnSyncQueue判断node是否在等待获取锁的同步链表中，对于刚创建的ConditionWaiter节点，
            // 没有将其加入到等待获取锁的同步链表中
   			// 只是将其加入到通过nextWaiter属性维护的条件链表中了，该方法返回false
   			// 等该节点被signal方法唤醒后就会将其加入到同步链表中了，该方法返回true
   			// 检测此节点是否在同步队列上，如果不在，说明此线程还没有资格竞争锁，此线程就继续挂起睡觉。
			// 直到检测到此节点在同步队列上(在有线程发出signal信号的时候)
            while (!isOnSyncQueue(node)) {
            	//挂起当前线程，当别的线程调用了signal（），并且是当前线程被唤醒的时候才从park()方法返回
                LockSupport.park(this);
                // 如果线程被中断过将interrupted 置为true，此时会继续循环，直到被唤醒，node加入到同步链表中，while循环退出
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            // 当被唤醒后，该线程会尝试去获取锁，只有获取到了才会从await()方法返回，否则的话，会挂起自己
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            // 清理条件队列中不是在等待条件的节点
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

调用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)
                	// 条件队列为null,执行完本次循环，直接退出
                    lastWaiter = null; 
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&
                     (first = firstWaiter) != null);
        }

通过调用同步器的enq方法，等待队列中的头节点线程安全地移动到同步队列。当节点移动到同步队列后，当前线程使用LockSupport唤醒该节点地线程。
被唤醒后地线程，将从await方法中地while循环中退出while (!isOnSyncQueue(node))返回true，节点已经在同步队列中，进而调用acquireQueued方法加入到获取同步状态地竞争中。
成功获取同步状态之后，被唤醒地线程将从先前调用地await方法返回，此时该线程已经成功地获取了锁

    final boolean transferForSignal(Node node) {
        // 将condition状态设置为初始状态，如果失败，说明被取消，返回false
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            return false;
        // 加入同步队列中
        Node p = enq(node);
        int ws = p.waitStatus;
        // 前继节点 ws > 0代表取消
    	// 设置前继节点的ws为SIGNAL，预示其后继节点要被唤醒
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        	// 如果被取消或者更新状态失败，则直接唤醒
            LockSupport.unpark(node.thread);
        return true;
    }