AQS条件对象
在AQS队列中通过nextWaiter指针串起来的就是条件队列，实际上是通过ConditionObject来实现的。ConditionObject类实现了Condition接口。Condition 实现可以提供不同于 Object 监视器方法的行为和语义。比如一个对象里面可以有多个Condition,可以注册在不同的condition，可以有选择性的调度线程，很灵活。而Synchronized只有一个condition（就是对象本身）,所有的线程都注册在这个conditon身上，线程调度不灵活。
Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。Condition 实例实质上被绑定到一个锁上。要为特定 Lock实例获得 Condition 实例，请使用其 newCondition() 方法。
条件变量在某个状态条件到达之前一直挂起该线程，由于多个线程都会访问这个共享状态信息，因此这个状态信息必须是线程安全的，这时就需要有锁来支撑。比如等待一个条件变量需要以原子方式释放获取的锁，并挂起当前线程，这和object.wait()类似。
以下是Condition接口的主要方法：
public interface Condition {
void await() throws InterruptedException;
void awaitUninterruptibly();
long awaitNanos(long nanosTimeout) throws InterruptedException;
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;
void signal();
void signalAll();
}
多个wait方法对应object.wait()方法，signal方法对应object.notify()方法，signalAll方法对应object.notifyAll()方法。下面分析每个方法的实现过程：
await操作，前面说过await主要做了两件事：释放锁，然后挂起当前线程，以下是它的具体实现：
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);
}
1、通过addConditionWaiter把当前线程加到条件队列
/**
* Adds a new waiter to wait queue.
* @return its new wait node
*/
private Node addConditionWaiter() {
Node t = lastWaiter;
// If lastWaiter is cancelled, clean out.
if (t != null && t.waitStatus != Node.CONDITION) {
unlinkCancelledWaiters();
t = lastWaiter;
}
Node node = new Node(Thread.currentThread(), Node.CONDITION);
if (t == null)
firstWaiter = node;
else
t.nextWaiter = node;
lastWaiter = node;
return node;
}
a、如果条件队列队尾结点waitStatus不为CONDITION,证明该条件队列可能包含被取消的线程，unlinkCancelledWaiters操作正是踢掉这些waitStatus不为CONDITION的结点。
b、新建一个含有当前线程的结点放到条件队列尾部
c、返回新结点
2、然后是释放当前结点拥有的锁，不然会造成死锁，这是通过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;
}
}
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
fullyRelease首先获取state，然后调用release方法释放锁，如果释放成功，直接返回，如果释放失败，证明当前结点存在异常，设置当前结点为CANCEL。
release方法是调用tryRelease来实现的，tryRelease成功后需要唤醒在等待的线程，此处唤醒的是同步队列中的第一个非CANCEL结点。
3、自旋挂起当前线程，直到被唤醒，超时或者被CANCEL.这是通过while循环实现的，如果没有在同步队列中就会一直挂起。是否在同步队列是通过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);
}
显然waitStatus为CONDITION这种结点，只属于条件队列，不在同步队列中。
4、 获取锁，并从条件队列中移除，表示它已经拿到锁了。获取锁是通过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);
}
}
acquireQueued的过程如下：
a、如果当前结点的前一个结点是傀儡节点，就尝试获取锁，如果获取成功就设置头结点为当前结点。
b、到此表明还有其他结点在排除，当前就应该被挂起，挂起当前线程，设置中断标志，然后返回。
整个await就经过这几步（释放锁---加入条件队列----挂起---条件满足进入同步队列），其他await方法过程差不多，这里不再分析了。
signal就是要将条件队列中的第一个结点唤醒，以下是它的具体实现：
/**
* Moves the longest-waiting thread, if one exists, from the
* wait queue for this condition to the wait queue for the
* owning lock.
*
* @throws IllegalMonitorStateException if {@link #isHeldExclusively}
* returns {@code false}
*/
public final void signal() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignal(first);
}
1、首先判断正在运行是不是当前线程，如果不是，则抛出异常！这是通过 isHeldExclusively来实现的，isHeldExclusively方法在AQS中是一个抽象方法，有多种实现，以下是在ReentrantLock中的实现：
protected final boolean isHeldExclusively() {
// While we must in general read state before owner,
// we don't need to do so to check if current thread is owner
return getExclusiveOwnerThread() == Thread.currentThread();
}
2、然后调用doSignal方法唤醒第一个线程
private void doSignal(Node first) {
do {
if ( (firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
first.nextWaiter = null;
} while (!transferForSignal(first) &&
(first = firstWaiter) != null);
}
final boolean transferForSignal(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))
LockSupport.unpark(node.thread);
return true;
}
doSignal()方法是一个while循环，直到transferForSignal成功为止，transferForSignal做了两件事，1、将结点从条件队列移到同步队列中，2、设置同步中它的前趋结点的waitStatus为SIGNAL,并挂起当前线程。其实doSignal就是不断地完成这样一个transfer（条件队列--->同步队列）操作，直到有一个成功为止。
signalAll就是唤醒条件列表中的所有线程，实现很简单，循环调用signal方法即可。
public final void signalAll() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignalAll(first);
}
/**
* Removes and transfers all nodes.
* @param first (non-null) the first node on condition queue
*/
private void doSignalAll(Node first) {
lastWaiter = firstWaiter = null;
do {
Node next = first.nextWaiter;
first.nextWaiter = null;
transferForSignal(first);
first = next;
} while (first != null);
}