一、简介
JUC中的ReentrantLock给我们提供了方便的加锁解锁操作，但是我们有时候会需要有条件的对线程进行挂起和唤醒，此时另一个工具就排上了用场。下面是Condition变量的常用用法。
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
Thread thread1 = new Thread(() -> {
try {
lock.lock();
System.out.println("我要等一个新信号");
condition.await();
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("拿到一个信号！！");
lock.unlock();
}, "waitThread");
Thread thread2 = new Thread(() -> {
lock.lock();
System.out.println("我拿到锁了");
try {
Thread.sleep(3000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
condition.signal();
System.out.println("我发了一个信号！！");
lock.unlock();
}, "signalThread");
thread1.start();
thread2.start();
}
运行完之后的结果：
我要等一个新信号
我拿到锁了
我发了一个信号！！
拿到一个信号！！
线程1获取到锁之后调用Condition的await()方法，该方法会释放锁，并将当前线程挂起。随后线程2会拿到锁，并执行signal()方法，该方法会唤起线程1，并释放锁，然后线程1拿到锁，执行后续的流程。
所以说Condition是一个多线程间协调通信的工具，使得某个，或者某些线程一起等待某个条件（Condition），只有当该条件具备( signal 或者 signalAll方法被调用)时 ，这些等待线程才会被唤醒，从而重新争夺锁。
那么，这些逻辑具体是怎么实现的呢？
首先，必须要明确，在线程调用await()或者signal()/signalAll()方法时，必须首先获取锁，否则会出现java.lang.IllegalMonitorStateException异常。其次，Condition（其实是ConditionObject，Condition接口的实现）维护了一个所有等待Condition条件变量的线程的队列，每个线程构成一个Node结点，也就是AQS中的Node结点：
/** First node of condition queue. */
private transient Node firstWaiter;
/** Last node of condition queue. */
private transient Node lastWaiter;
二、await()
以Condition condition = lock.newCondition();为例，newCondition()会调用Sync的newCondition()方法：
public Condition newCondition() {
return sync.newCondition();
}
Sync的newCondition()方法：
final ConditionObject newCondition() {
return new ConditionObject();
}
//ConditionObject是AQS中的内部类，实例属性只有上面的firstWaiter和lastWaiter
public ConditionObject() { }
对于await()方法，可以抛出中断异常，
public final void await() throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
//将当前线程封装成Node结点，添加到Condition的等待队列中
Node node = addConditionWaiter();
int savedState = fullyRelease(node); //释放所占的锁，因为在调用await()方法时，是占有锁的
int interruptMode = 0;
//释放了锁之后，判断当前线程的node结点是不是在syncQueue中，
//什么是syncQueue呢？就是获取锁不成功而被挂起的线程所在的那个队列
//如果不在syncQueue中，说明当前线程还不具备获取锁的资格，就将当前线程挂起，直到被添加到阻塞队列中，
while (!isOnSyncQueue(node)) {
LockSupport.park(this); //线程被挂起，等待被signal唤醒，此时可以直接跳到下面的signal方法解析
//挂起的过程中，如果被中断了，线程被唤醒，跳出while循环
//如果没被中断，则此时node已经在阻塞队列中了，也会跳出循环
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
//此时线程已经被唤醒，node结点已经被添加到阻塞队列中准备获取锁，被谁添加到阻塞队列了呢，是signal
//acquireQueued尝试获取锁，被中断返回true，否则返回false
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null) // clean up if cancelled
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
其他版本的await()方法和这个类似，读者可以自行尝试分析。
三.signal()
//ConditionObject
public final void signal() {
//如果在没有获取锁的情况下调用signal，会抛出IllegalMonitorStateException异常
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter; //拿到队列中的第一个node，此队列是Condition队列
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);
}
//该方法是将结点移到阻塞队列中，使得当前node节点的线程可以有资格获取锁
final boolean transferForSignal(Node node) {
/*
* If cannot change waitStatus, the node has been cancelled.
*/
//在加入阻塞队列之前，将node的waitStatus设置为0，如果失败，说明该节点已经被取消，
//返回false，此时上面的doSignal方法会继续遍历Condition队列，
//找到第一个还在等待Condition变量的结点
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).
*/
//将结点加入到阻塞队列，返回的p结点是node的前置节点
Node p = enq(node);
int ws = p.waitStatus;
//如果前一个节点已经被取消等待(ws>0)，或者修改waitStatus失败，则直接唤醒。
//正常情况 ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL)这个判断
//是不会为true的，所以，不会在这个时候唤醒该线程。
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
LockSupport.unpark(node.thread);
return true; //成功转移到阻塞队列，返回true
}
那么什么时候才会唤醒呢？当前线程调用完 signal()之后，执行lock.unlock()方法之后，释放锁的时候，会唤醒其他线程，这个就是unlock()的逻辑了。
signalAll()方法的逻辑与signal()类似，读者可以自己分析一遍。
四.总结
现在我们再来理一遍：
一个线程Alock.lock()获取锁成功之后，调用condition.await()方法，该方法会首先将线程封装成node加入Condition队列，然后释放锁，将线程移出阻塞队列，然后挂起；另一个线程B因为之前线程释放锁，获取锁成功，调用signal()方法，将Condition队列的第一个node转移到阻塞队列，这个时候还没完，执行完signal之后会释放锁，此时会唤醒后面的线程，此时线程A有机会竞争到锁。
