ConditionObject
ConditionObject是AQS中的内部类，提供了条件锁的同步实现，实现了Condition接口，并且实现了其中的await(),signal(),signalALL()等方法。
ConditionObject主要是为并发编程中的同步提供了等待通知的实现方式，可以在不满足某个条件的时候挂起线程等待。直到满足某个条件的时候在唤醒线程。
在一个AQS同步器中，可以定义多个Condition，只需要多次lock.newCondition(),每次都会返回一个新的ConditionObject对象。在ConditionObject中，通过一个等待队列来维护条线等待的线程。所以在一个同步器中可以有多个等待队列，他们等待的条件是不一样的。
条件队列
条件队列是一个FIFO的队列，在队列的每个节点都包含了一个线程引用。该线程就是在Condition对象上等待的线程。这里的节点和AQS中的同步队列中的节点一样，使用的都是AbstractQueuedSynchronizer.Node类。每个调用了condition.await()的线程都会进入到条件队列中去。在Condition中包含了firstWaiter和lastWaiter，每次加入到条件队列中的线程都会加入到条件队列的尾部，来构成一个FIFO的条件队列。
方法分析
await()方法的具体实现
public final void await() throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); Node node = addConditionWaiter(); //把当前线程的节点加入到CONDITION队列中 int savedState = fullyRelease(node); //由于调用await()方法的线程是已经获取了锁的，所以在加入到CONDITION队列之后，需要去释放锁，并且唤醒后继节点线程 int interruptMode = 0; while (!isOnSyncQueue(node)) { //判断该节点是否在CLH队列中，不在 说明它还没有竞争锁的资格，所以继续将自己沉睡,线程进入自旋。 LockSupport.park(this); //挂起当前线程，当别的线程调用了signal（），并且是当前线程被唤醒的时候才从park()方法返回 if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) break; } //出了while循环，代表线程被唤醒，并且已经将该node从CONDITION队列transfer到了CLH队列中 //acquireQueued在队列中获取锁，如果竞争不到还是会阻塞当前线程，并且在上面while循环等待的过程中没有发生异常，则修改interruptMode状态为REINTERRUPT if (acquireQueued(node, savedState) && interruptMode != THROW_IE) //当被唤醒后，该线程会尝试去获取锁，只有获取到了才会从await()方法返回，否则的话，会挂起自己 interruptMode = REINTERRUPT; //该节点调用transferAfterCancelledWait添加到CLH队列中的，此时该节点的nextWaiter不为null，需要调用unlinkCancelledWaiters将该节点从CONDITION队列中删除，该节点的状态为0 if (node.nextWaiter != null) // clean up if cancelled unlinkCancelledWaiters(); //如果interruptMode不为0，则代表该线程在上面过程中发生了中断或者抛出了异常，则调用reportInterruptAfterWait方法在此处抛出异常 if (interruptMode != 0) reportInterruptAfterWait(interruptMode); }
addConditionWaiter( )
private Node addConditionWaiter() { Node t = lastWaiter; if (t != null && t.waitStatus != Node.CONDITION) { //首先判断lastWaiter节点是否为空，或者是否是处于条件等待，如果不是的话则把它从等待队列中删除。 unlinkCancelledWaiters(); t = lastWaiter; } Node node = new Node(Thread.currentThread(), Node.CONDITION); //创建一个node节点，状态为CONDITION if (t == null) //把当前线程构建的节点加入到CONDITION队列中去，并且返回当前节点 firstWaiter = node; else t.nextWaiter = node; lastWaiter = node; return node; }
fullyRelease( )
//完全释放锁,释放成功则返回，失败则将当前节点的状态设置成cancelled表示当前节点失效 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; //释放锁失败，则当前节点的状态变为cancelled（此时该节点在CONDITION队列中） }
}
signal()
//对CONDITION队列中从首部开始的第一个CONDITION状态的节点，执行transferForSignal操作，将node从CONDITION队列中转换到CLH队列中，同时修改CLH队列中原先尾节点的状态 private void doSignal(Node first) { do { //当前循环将first节点从CONDITION队列transfer到CLH队列 //从CONDITION队列中删除first节点，调用transferForSignal将该节点添加到CLH队列中，成功则跳出循环 if ( (firstWaiter = first.nextWaiter) == null) lastWaiter = null; first.nextWaiter = null; } while (!transferForSignal(first) && (first = firstWaiter) != null); } //唤醒CONDITION队列中首部的第一个CONDITION状态的节点
public final void signal() { if (!isHeldExclusively()) //判断当前线程是不是独占的持有锁，如果不是，则当前线程不能signal其他线程 。 throw new IllegalMonitorStateException(); Node first = firstWaiter; if (first != null) //CONDITION队列不为null，则doSignal方法将唤醒CONDITION队列中所有的节点线程 doSignal(first); }
transferForSignal( )
//两步操作，首先enq将该node添加到CLH队列中，其次若CLH队列原先尾节点为CANCELLED或者对原先尾节点CAS设置成SIGNAL失败，则唤醒node节点； //否则该节点在CLH队列总前驱节点已经是signal状态了，唤醒工作交给前驱节点（节省了一次park和unpark操作） final boolean transferForSignal(Node node) { //如果CAS失败，则当前节点的状态为CANCELLED if (!compareAndSetWaitStatus(node, Node.CONDITION, 0)) return false; Node p = enq(node); //enq将node添加到CLH队列队尾，返回node的前一个节点 //如果p是一个取消了的节点，或者对p进行CAS设置失败，则唤醒node节点，让node所在线程进入到acquireQueue方法中，重新进行相关操作 //否则，由于该节点的前驱节点已经是signal状态了，不用在此处唤醒await中的线程，唤醒工作留给CLH队列中前驱节点 int ws = p.waitStatus; if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL)) LockSupport.unpark(node.thread); //唤醒刚加入到同步队列的线程，被唤醒之后，该线程才能从await()方法的park()中返回。 return true; }
signalAll( )
public final void signalAll() { //查看当前线程是否独占锁，若不是，则当前线程没有权限执行signalAll操作，抛出异常 if (!isHeldExclusively()) throw new IllegalMonitorStateException(); Node first = firstWaiter; //唤醒CONDITION队列中所有节点，同时transfer到CLH队列中 if (first != null) doSignalAll(first); } private void doSignalAll(Node first) { lastWaiter = firstWaiter = null; do { //将first节点从CONDITION队列中出队 Node next = first.nextWaiter; first.nextWaiter = null; //将first节点在CLH队列中入队，同时可能需要执行unpark操作 transferForSignal(first); //更新first的指向 first = next; } while (first != null); }
条件队列的节点状态
调用条件队列的等待操作，会设置节点的waitingStatus为Condition，标识当前节点正处于条件队列中。条件队列的节点状态转换图如下：
Node的各个状态的主要作用：Cancelled主要是解决线程在持有锁时被外部中断的逻辑，AQS的可中断锁获取方法lockInterrutible()是基于该状态实现的。显式锁必须手动释放锁，尤其是有中断的环境中，一个线程被中断可能仍然持有锁，所以必须注意在finally中unlock。Condition则是支持条件队列的等待操作，是Lock与条件队列关联的基础。Signal是阻塞后继线程的标识，一个等待线程只有在其前驱节点的状态是SIGNAL时才会被阻塞，否则一直执行自旋尝试操作，以减少线程调度的开销。
等待和唤醒操作
条件队列上的等待和唤醒操作，本质上是节点在AQS线程等待队列和条件队列之间相互转移的过程，当需要等待某个条件时，线程会将当前节点添加到条件队列中，并释放持有锁；当某个线程执行条件队列的唤醒操作，则会将条件队列的节点转移到AQS等待队列。每个Condition就是一个条件队列，可以通过Lock的newCondition创建多个等待条件。AQS的条件队列，它的等待和唤起操作流程如下：
显式条件队列弥补了内置条件队列只能关联一个条件的缺陷，同时继承了Lock对象的公平性。在Condition对象中，与Object的wait/notify/notifyAll对应的扩展方法是await/signal/signallAll，同时它也具有Object的这三个方法，所以使用的时候需要注意使用版本的正确。另外，显式锁必须遵从特定的使用规范，先lock，然后再在finally中unlock，以确保锁必然会被正确释放。
Condition示例
package concurrent; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @Description: Condition实例 * @Author: lizhouwei * @CreateDate: 2018/5/27 16:39 */ public class ConditionDemo { private static Lock reentrantLock = new ReentrantLock(); private static Condition condition = reentrantLock.newCondition(); public static void main(String[] args) { ThreadA threadA = new ThreadA("threadA"); reentrantLock.lock(); try { System.out.println(Thread.currentThread().getName()+" 我拿到锁了"); threadA.start(); System.out.println(Thread.currentThread().getName()+" 我释放锁了"); condition.await(); System.out.println(Thread.currentThread().getName()+" 我又拿到锁了"); } catch (InterruptedException e) { e.printStackTrace(); } finally { reentrantLock.unlock(); } } static class ThreadA extends Thread{ public ThreadA(String name) { super(name); } public void run() { reentrantLock.lock(); try { System.out.println(Thread.currentThread().getName()+"我拿到锁了"); condition.signal(); System.out.println(Thread.currentThread().getName()+"我唤醒其他线程了"); } finally { reentrantLock.unlock(); } } } }
运行结果
可以看到Condition的执行方式，
- 线程1调用
reentrantLock.lock时，线程被加入到AQS的等待队列中。 - 线程1调用wait方法被调用时，该线程从AQS中移除，对应操作是锁的释放。
- 接着线程1马上被加入到Condition的等待队列中，意味着该线程需要
signal信号。 - 线程2，因为线程1释放锁的关系，被唤醒，并判断可以获取锁，于是线程2获取锁。
- 线程2调用
signal方法，这个时候Condition的等待队列中只有线程1一个节点，于是它被取出来，并被加入到AQS的等待队列中。 注意，这个时候，线程1 并没有被唤醒。 signal方法执行完毕，线程2调用reentrantLock.unLock()方法，释放锁。这个时候因为AQS中只有线程1，于是，AQS释放锁后按从头到尾的顺序唤醒线程时，线程1被唤醒，于是线程1回复执行。- 直到释放所整个过程执行完毕。
可以看到，整个协作过程是靠结点在AQS的等待队列和Condition的等待队列中来回移动实现的，Condition作为一个条件类，很好的自己维护了一个等待信号的队列，并在适时的时候将结点加入到AQS的等待队列中来实现的唤醒操作。