一、引言
一般我们在使用锁的Condition时，我们一般都是这么使用，以ReentrantLock为例，
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
lock.lock();
try{
condition.await();
}finally{
lock.unlock();
}
lock.lock();
try{
condition.signal();
}finally{
lock.unlock();
}
从上面可以知道，我们调用Condition的await和signal方法必须是在获取得到锁的情况下，首先我们以这个为基础，先不管是如何获取得到锁的，那么上面的程序在condition.await()时阻塞当前调用的线程，而调用 condition.signal()方法的时候可能唤起一个正在await阻塞的线程，我这里说的是可能不是一定。为什么这么说，我们来看下await()方法主要做了什么事情。
二、分析
下面是await 方法的在jdk8的源码，
下面是await 方法的在jdk8的源码，
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);
}
执行过程如下，
① ，判断当前显示是否被interrupt? 是的话，会抛出中断异常InterruptedException,
② ，调用addConditionWaiter方法，主要是new 一个以当前线程为数据的节点Node,然后添加到condition条件队列里。
③ ，调用fullyRelease方法，该方法内部调用release方法，而release方法主要是在AQS队列里面唤起第一个节点（即head的next节点）的线程（如果head后继节点存在的话）。这时，在ASQ同步器内至少有2个活动的线程（一个是当前线程(可能是头节点)，另一个是唤起的线程（如果存在））。如果唤起失败，会抛异常IllegalMonitorStateException。注：当存在唤起的线程的时候，这个线程就可以去争取获取锁。
④ ，通过isOnSyncQueue方法判断该节点是否在AQS队列中，当调用await时候，肯定不在AQS上，因为addConditionWaiter方法是new 一个新的Node.接着会进入while循环里面。调用 LockSupport.park(this);阻塞当前线程，相当于释放锁。
⑤ ，当当前线程被唤起的时候（可能是 另一个await线程唤起的第一个节点可能是这个线程，或者在signal下，前驱节点已经cancel时，第一个firstWaiter节点是该当前节点），需要判断是否被中断，存储在interruptMode，如果被中断则break,否则checkInterruptWhileWaiting返回0，那么会接着判断node节点是否在AQS中，如果还是不在的话，park当前线程，否则跳出while循环。那么node节点是什么时候被加入到AQS上的，答案是在signal方法上。
⑥ ，当node节点在AQS队列时，我们需要获取锁，只有当前线程的节点Node在AQS队列上，才能去争取锁。争取锁就是通过调用acquireQueued方法。等下来分析下acquireQueued方法。
⑦ ， 如果当前节点的node.nextWaiter不为空，说明还有其他线程在该condition上，并且当前的线程已经获取锁，接着清除条件队列上的cancel类型节点
⑧ ， 如果interruptMode 是InterruptedException类型或者REINTERRUPT类型。则进行相应的抛中断异常或者线程自我中断标志位设置。
接着，来分析下signal方法
public final void signal() {
if (!isHeldExclusively()) // ①
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignal(first); // ②
}
执行过程如下，
① ，如果当前线程不是持有该condition的锁，那么执行抛IllegalMonitorStateException异常。
② ，调用doSignal方法，并且条件队列的首节点传入。
private void doSignal(Node first) {
do {
if ( (firstWaiter = first.nextWaiter) == null) // ①
lastWaiter = null;
first.nextWaiter = null;
} while (!transferForSignal(first) && (first = firstWaiter) != null); // ②
}
① ，这种条件队列firstWaiter指针为next节点，因为当前的节点需要被移除条件队列，并且next节点为空，那么lastWaiter置为null,说明是空条件队列，接着把first.nextWaiter=null,说明移除了条件队列
② ，在这里有2步操作，一是transferForSignal,二是 first = firstWaiter，如果我们当前first节点入AQS队列成功，那么transferForSignal返回true,则doSignal的while循环结束，
如果当前的first节点入AQS返回失败，则需要next的节点重新signal，保证有一个成功的firstWaiter节点入AQS队列。接着来看下transferForSignal 方法主要做了什么事情。
final boolean transferForSignal(Node node) {
/*
* If cannot change waitStatus, the node has been cancelled.
*/
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0)) // ①
return false;
/*
* Splice onto queue and try to set waitStatus of predecessor to
* indicate that thread is (probably) waiting. If cancelled or
* attempt to set waitStatus fails, wake up to resync (in which
* case the waitStatus can be transiently and harmlessly wrong).
*/
Node p = enq(node); // ②
int ws = p.waitStatus;
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL)) // ③
LockSupport.unpark(node.thread);
return true;
}
① ，首先传入的节点node是条件队列的第一个节点（在外部已经移除），改变其状态CONDITION，为初始状态0,如果改变失败，说明该节点已经不是条件节点，直接返回false,doSignal方法重新调用新firstWaiter节点入AQS队列，
② ，把首节点入AQS节点,enq（）方法返回的是入节点的前驱节点。从这里核心方法可以知道，signal() 方法的作用其实只是把等待队列中第一个非取消节点转移到AQS的同步队列尾部。转移后的节点很可能正在在同步队列阻塞着，什么时候唤醒，取决于它的前驱节点是否是头节点。
③ ，如果当前前驱节点的waitStatus>0(说明是CANCELLED状态)，前驱节点已经Canncel（说明前驱节点已经中断等情况），则可以调用LockSupport.unpark(node.thread)唤起线程，则await方法的park返回可以立即返回，预先将AQS同步队列中取消的节点移除掉，而不用等到获取同步状态失败的时候再去判断了，起到一定的优化作用。
最后来分析下获取锁方法 acquireQueued
执行如下：
final boolean acquireQueued(final Node node, int arg) { // ①
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) { //②
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) // ③
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
① ，传入node 为需要获取锁的节点，arg为之前state状态.
② ，如果传入的节点的前驱节点是head节点，说明当前节点是AQS队列的首节点，可以尝试去获取锁，即我们需要是要实现的同步语义方法tryAcquire，如果同步语义获取锁成功，则设置当前头节点为头节点。
这里注意返回的值得语义是是否发生中断，而不是获取锁是否成功。
③ ，调用 shouldParkAfterFailedAcquire方法，该方法用来判断获取锁失败后是否需要park当前线程，如果需要park线程，则接着判断该线程是否有中断标志。
接着我们来看下shouldParkAfterFailedAcquire 方法。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL) // ①
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true;
if (ws > 0) { // ②
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* waitStatus must be 0 or PROPAGATE. Indicate that we
* need a signal, but don't park yet. Caller will need to
* retry to make sure it cannot acquire before parking.
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL); //③
}
return false;
}
① 前驱节点pred的waitStatus为SIGNAL，说明当前节点有效，返回true,代表需要park当前线程，
② 前驱节点已经取消，则删除去取消掉的前驱节点，返回false，外面继续for循环获取锁
③ 处在该条件语句的前驱节点的waitStatus必定是 0,或者是传播PROPAGATE，则设置传播节点为SIGNAL，然后返回false,则接着去for循环获取锁，并且失败的时候，调用shouldParkAfterFailedAcquire时知道前驱为SIGNAL（之前由③设置），则需要park线程。
从这里可以知道transferForSignal方法中，!compareAndSetWaitStatus(p, ws, Node.SIGNAL)语句，如果对其前驱节点设置Node.SIGNAL失败，则不需要等到acquireQueued去判断是否需要park线程，直接unpark线程即可