1 什么是条件锁？
条件锁，是指在获取锁之后发现当前业务场景自己无法处理，而需要等待某个条件的出现才可以继续处理时使用的一种锁。
这里的条件，必须是在获取锁之后去等待，对应到ReentrantLock的条件锁，就是获取锁之后才能调用condition.await()方法。
在java中，条件锁的实现都在AQS的ConditionObject类中，ConditionObject实现了Condition接口，下面我们通过一个例子来进入到条件锁的学习中。
2 源码分析
2.1 ConditionObject的主要属性
public class ConditionObject implements Condition, java.io.Serializable {
private static final long serialVersionUID = 1173984872572414699L;
/** First node of condition queue. */
private transient Node firstWaiter;
/** Last node of condition queue. */
private transient Node lastWaiter;
}
可以看见条件锁中也维护了一个队列，为了和AQS的队列区分，这里称为条件队列，firstWaiter是队列的头节点，lastWaiter是队列的尾节点
2.2 新建条件锁方法 lock.newCondition(）
public Condition newCondition() {
return sync.newCondition();
}
final ConditionObject newCondition() {
return new ConditionObject();
}
// AbstractQueuedSynchronizer.ConditionObject.ConditionObject()
public ConditionObject() { }
新建一个条件锁最后就是调用的AQS中的ConditionObject类来实例化条件锁。
2.3 condition.await()方法
condition.await()方法，表明现在要等待条件的出现。
AbstractQueuedSynchronizer.ConditionObject.await()方法
public final void await() throws InterruptedException {
// 如果线程中断了,抛出异常
if (Thread.interrupted())
throw new InterruptedException();
// 添加节点到Condition的条件队列中，并返回该节点
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的条件等待队列中，addConditionWaiter()方法
private Node addConditionWaiter() {
Node t = lastWaiter;
// If lastWaiter is cancelled, clean out.
// 如果条件队列的尾节点已取消，从头节点开始清除所有已取消的节点
if (t != null && t.waitStatus != Node.CONDITION) {
unlinkCancelledWaiters();
// 重新获取尾节点
t = lastWaiter;
}
// 新建一个节点，它的等待状态是condition
Node node = new Node(Thread.currentThread(), Node.CONDITION);
// 如果尾节点为空，则把新节点赋值给头节点（相当于初始化队列）
// 否则把新节点赋值给尾节点的nextWaiter指针
if (t == null)
firstWaiter = node;
else
t.nextWaiter = node;
// 尾节点指向新节点
lastWaiter = node;
return node;
}
释放全部锁fullyRelease()方法，返回获得锁的次数
final int fullyRelease(Node node) {
boolean failed = true;
try {
// 获取状态变量的值，该值也代表获取锁的次数
int savedState = getState();
// 一次性释放所有获得的锁
if (release(savedState)) {
failed = false;
// 返回获得锁的次数
return savedState;
} else {
throw new IllegalMonitorStateException();
}
} finally {
if (failed)
node.waitStatus = Node.CANCELLED;
}
}
判断节点是否在同步队列中，AbstractQueuedSynchronizer.isOnSyncQueue中
final boolean isOnSyncQueue(Node node) {
// 如果等待状态是Condition，或者前一个指针为空，返回false
// 说明还没有移到AQS的队列中
if (node.waitStatus == Node.CONDITION || node.prev == null)
return false;
// 如果next指针有值，说明已经移到AQS的队列中了
if (node.next != null) // If has successor, it must be on queue
return true;
// 从AQS的尾节点开始往前寻找看是否可以找到当前节点，找到了也说明已经在AQS的队列中了
return findNodeFromTail(node);
}
注意：
<1> Condition的队列和AQS的队列不完全一样；
AQS的头节点不存在任何值的，是一个虚节点；
Condition的队列头节点是存储实实在在的元素值的，是真实节点
<2> 各种等待状态(waitStatus)的变化
首先，在条件队列中，新建节点的初始等待状态是CONDITION(-2);
其次，移到AQS的队列中等待状态就会变为0，（AQS队列节点的初始等待状态为0）
然后，在AQS的队列中如果需要阻塞，会把它上一个节点的等待状态设置为SIGNAL（-1）
最后，不管在Condition队列还是AQS队列中，已取消的节点的等待状态都设置为CANCELED（1）
<3> 相似的名称
AQS中下一个节点是next，上一个节点是prev；
Condition中下一个节点是nextWaiter ，没有上一个节点。
另外：所以AQS中存在两种队列，一种是同步队列，一种是条件队列。
每个Condition都对应着一个条件队列；一个锁上可以创建多个Condition对象，那么也就存在多个条件队列。条件队列同样是一个FIFO的队列，在队列中每一个节点都包含了一个线程的引用，而该线程就是Condition对象上等待的线程。
当一个线程调用了await()相关的方法，那么该线程将会释放锁，并构建一个Node节点封装当前线程的相关信息加入到条件队列中进行等待，直到被唤醒、中断、超时才从队列中移出。Condition中的等待队列模型如下
条件队列中节点的状态只有两种，即CANCELLED和CONDITION（前者表示线程已结束需要从等待队列中移除，后者表示条件节点等到被唤醒）
await()主要做了三件事：
一是调用addConditionWaiter()方法将当前线程封装成node结点加入等待队列。
二是调用fullyRelease(node)方法释放同步状态并唤醒后继结点的线程。
三是调用isOnSyncQueue(node)方法判断结点是否在同步队列中，这里是个while循环，如果同步队列中没有该结点就直接挂起该线程，需要明白的是如果线程被唤醒后就调用acquireQueued(node, savedState)执行自旋操作争取锁，即当前线程结点从等待队列转移到同步队列并开始努力获取锁。
2.4 condition.signal()方法
condition.signal()方法通知条件已经出现。
AbstractQueuedSynchronizer.ConditionObject.signal方法
public final void signal() {
// 如果不是当前线程占有着锁，调用这个方法抛出异常
// 说明signal()方法也要在获取锁之后执行
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
// 条件队列的头节点
Node first = firstWaiter;
// 如果有等待条件的节点，则通知条件成立
if (first != null)
doSignal(first);
}
AbstractQueuedSynchronizer.ConditionObject.doSignal方法
while条件，如果被通知节点没有进入到同步队列并且条件等待队列还有不为空的节点，则继续循环通知后续结点
private void doSignal(Node first) {
do {
// 移除条件等待队列中的第一个节点
// 如果后继节点为null，那么说明没有其他节点，将尾节点也设置为null
if ( (firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
// 相当于将头节点从队列中出队
first.nextWaiter = null;
// 转移节点到AQS队列中去
} while (!transferForSignal(first) &&
(first = firstWaiter) != null);
}
转移节点到AQS队列中
final boolean transferForSignal(Node node) {
/*
* If cannot change waitStatus, the node has been cancelled.
*/
// 把节点的状态更改为0，也就是即将移到AQS队列中
// 如果失败了，说明节点已经改成取消状态了
// 返回false，通过上面的循环可知会寻找下一个可用节点
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
return false;
// 调用AQS的入队方法将节点移到AQS队列中
// 这里的enq的返回值是node的上一个节点，就是旧尾节点
Node p = enq(node);
// 上一个节点的等待状态
int ws = p.waitStatus;
// 如果上一个节点已经取消了，或者更新状态为signal失败
// 则直接唤醒当前节点对应的线程
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
LockSupport.unpark(node.thread);
return true;
}
如果更新上一个节点的等待状态为signal成功了，则返回true，这个时候，上面的循环就不成立了，退出循环，也就是通知了一个节点。
此时，当前节点还是阻塞状态，也就是说调用signal()的时候并不会真正唤醒一个节点，只是把节点从条件队列移到AQS队列中
总结：
signal()方法：
（1）从条件队列的头节点开始寻找一个非取消状态的节点；
（2）把它从条件队列移到AQS队列；
（3）且只移动一个节点；
