内部实现类ConditionObject的继承与实现关系
//Condition接口的实现内部类
public class ConditionObject implements Condition, java.io.Serializable
常用属性及构造器
/** 等待队列的头节点 */
private transient Node firstWaiter;
/** 等待队列的尾节点 */
private transient Node lastWaiter;
/**
* 无参构造器
*/
public ConditionObject() { }
实现方法
await()方法：让当前线程处于等待状态。
await方法.png
public final void await() throws InterruptedException {
// 如果当前线程中断，抛出中断异常
if (Thread.interrupted())
throw new InterruptedException();
// 将当前线程作为一个等待节点添加到等待队列，返回当前等待队列中的尾节点
// 此时该节点node的等待状态为Condition（在等待队列中）
Node node = addConditionWaiter();
// 释放节点，就是将当前节点从同步队列中释放，返回保存的状态
int savedState = fullyRelease(node);
int interruptMode = 0;
// 循环判断的条件是node节点是否不在同步队列中
while (!isOnSyncQueue(node)) {
// 允许当前线程可用
LockSupport.park(this);
// 检查不处于等待状态时，是否中断，不为0，说明已经中断了，直接退出当前循环
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
// 如果节点node的前驱节点不为头节点，将阻塞node节点，一直等到其前驱节点为头节点为止
// 并且中断模型对应的值不为中断状态
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
// 如果节点node的后继节点不为null
if (node.nextWaiter != null) // clean up if cancelled
// 释放等待队列中取消等待状态的节点
unlinkCancelledWaiters();
// 如果当前中断模型值还是不为0，就是如果节点node还是处于中断情况
if (interruptMode != 0)
// 在等待状态之后，处理中断模型值
reportInterruptAfterWait(interruptMode);
}
addConditionWaiter()方法：将当前线程作为一个等待节点添加到等待队列。
private Node addConditionWaiter() {
// 获取等待队列的尾节点
Node t = lastWaiter;
// 如果尾节点不为null并且尾节点的等待状态不在等待队列中
if (t != null && t.waitStatus != Node.CONDITION) {
// 释放等待队列中取消等待状态的节点
unlinkCancelledWaiters();
// 由于释放了等待队列中取消等待状态的节点，导致尾等待节点可能发生变化，需要重新赋值
// 将t被赋值为等待队列的尾节点
t = lastWaiter;
}
// 将当前线程构造成一个处于等待队列中的节点
Node node = new Node(Thread.currentThread(), Node.CONDITION);
// 如果尾节点为空，说明等待队列中没有等待节点
if (t == null)
// 将当前线程构造的等待节点作为等待队列的头节点
firstWaiter = node;
else// 如果尾节点不为空，说明等待队列中存在等待节点
// 将当前线程构造的等待节点作为尾节点的后继节点
t.nextWaiter = node;
// 更新尾节点，将当前线程构造的节点作为尾节点
lastWaiter = node;
// 返回更新后尾节点
return node;
}
unlinkCancelledWaiters()方法：释放等待队列中取消等待状态的节点。
private void unlinkCancelledWaiters() {
// 获取等待队列的头节点
Node t = firstWaiter;
// 创建临时节点
Node trail = null;
// 从头节点开始遍历
while (t != null) {
// 获取当前遍历到的节点的后继节点
Node next = t.nextWaiter;
// 如果当前节点不在等待队列中
if (t.waitStatus != Node.CONDITION) {
// 后继节点则设置为null
t.nextWaiter = null;
// 如果临时节点为空，那么当前节点设置为后继节点
if (trail == null)
firstWaiter = next;
else// 如果临时节点不为空，那么临时节点的后继节点为当前节点的后继节点
trail.nextWaiter = next;
// 如果当前节点的后继节点为空，那么尾节点为临时节点
if (next == null)
lastWaiter = trail;
}
else// 如果当前节点在等到队列中
trail = t;// 将当前节点赋值给临时节点
t = next;// 后继节点作为当前遍历节点，向后遍历
}
}
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;
}
}
isOnSyncQueue方法：判断指定节点是否在同步队列中。
final boolean isOnSyncQueue(Node node) {
// 节点在等待队列中，肯定不在同步队列中
// 节点不在等待队列中，而其前驱节点为空，说明已经不在同步队列中了
if (node.waitStatus == Node.CONDITION || node.prev == null)
return false;
// 节点如果有后继节点，那么节点肯定在同步队列中
if (node.next != null) // If has successor, it must be on queue
return true;
// 从同步队列的尾节点开始向前遍历查找指定节点
return findNodeFromTail(node);
}
// 从同步队列的尾节点开始向前遍历查找，如果找到指定节点，那么返回true；如果未找到指定节点，那么返回false。
private boolean findNodeFromTail(Node node) {
Node t = tail;
for (;;) {
if (t == node)
return true;
if (t == null)
return false;
t = t.prev;
}
}
signal()方法：独占模式下，移出等待队列中等待时间最长的节点，将其移到同步队列。
signal方法.png
public final void signal() {
// 如果当前线程不是以独占的方式运行的，那么就抛出异常
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
// 获取等待队列的头节点
Node first = firstWaiter;
// 如果等待队列的头节点不为空
if (first != null)
// 将等待队列中的头节点从等待队列转移到同步队列
doSignal(first);
}
doSignal(Node first)方法：将等待节点first从等待队列转移到同步队列。
// 将等待节点first从等待队列转移到同步队列
private void doSignal(Node first) {
do {
// 如果输入节点的后继节点作为头节点，如果头节点为null
if ( (firstWaiter = first.nextWaiter) == null)
// 尾节点设置为空
lastWaiter = null;
// 输入节点的后继节点设置为null
first.nextWaiter = null;
} while (!transferForSignal(first) && // 将输入节点从等待队列转移到同步状态
// 并且头节点不为空
(first = firstWaiter) != null);
}
transferForSignal方法：将等待节点从等待队列转移到同步队列
final boolean transferForSignal(Node node) {
// 原子的方式比较节点node如果在等待队列中，那么将node更新为在同步队列中
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
return false;
// 将节点插入到同步队列尾部
Node p = enq(node);
int ws = p.waitStatus;
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
// 将node节点对应线程可用
LockSupport.unpark(node.thread);
return true;
}
doSignalAll(Node first)方法：将等待队列中的节点全部移出，然后转移到同步队列。
// 将等待队列中的节点全部移出，然后转移到同步队列
private void doSignalAll(Node first) {
// 设置等待队列的头节点等于尾节点等于null（等待队列的置空操作）
lastWaiter = firstWaiter = null;
// 策略就是将等待队列中的节点遍历一遍，然后每个节点的后继关系解除，然后转移到同步队列中
do {
// 获取输入节点的后继节点
Node next = first.nextWaiter;
// 将后继节点设置为空
first.nextWaiter = null;
// 将等待队列中的节点转移到同步队列中
transferForSignal(first);
// 后继节点作为当前节点，依次向后遍历
first = next;
} while (first != null);// 直到遍历到尾节点
}
说明：从头节点开始遍历等待队列中的节点，将每次遍历到的节点修改等待状态为在同步队列中，并将节点插入到同步队列的尾部。
总结
① 问题：节点什么时候从同步队列转移到等待队列
答：调用await方法的时候（将当前线程构造成一个等待状态为在等待队列中的节点，将节点插入到等待队列的尾部；释放在同步队列中的该节点，并且让该节点可用）。
② 问题：节点什么时候从等待队列转移到同步队列
答：调用signal方法的时候（判断当前等待队列中的头结点不为空，然后获取等待队列的头节点，修改等待状态为在同步队列中，再将节点插入到同步队列的尾部）。
---------------------------该源码为jdk1.7版本的
