ReentrantLock 的基本操作除了lock()和unlock()外，还有condition的await()和signal()。但是是通过调用AbstractQueuedSynchronizer的内部类CondtionObject来实现的。所以await()和singnal()的操作主要在CondtionObject类里。
如上图可以看到，ConditonObject是AbstractQueuedSynchronizer的内部类，同时上节讲解lock()和unlock()提到的Node也是它的内部类，以及其他方法组成了依赖FIFO waiting queue的阻塞锁和相关同步器（semaphores,events,等待）基本框架。
现在主要看一下内部类ConditionObject：
/**
* Condition implementation for a {@link
* AbstractQueuedSynchronizer} serving as the basis of a {@link
* Lock} implementation.
*
* Method documentation for this class describes mechanics,
* not behavioral specifications from the point of view of Lock
* and Condition users. Exported versions of this class will in
* general need to be accompanied by documentation describing
* condition semantics that rely on those of the associated
* {@code AbstractQueuedSynchronizer}.
*
*
This class is Serializable, but all fields are transient,
* so deserialized conditions have no waiters.
*/
public class ConditionObject implements Condition, java.io.Serializable {
一. await操作的流程：
因为线程是先通过lock()获得锁资源，然后调用await()时，先释放锁资源然后park。所以park前要先释放锁，让别的线程获得争取锁资源的权利。
调用流程图：
1.await()
/**
* Implements interruptible condition wait.
*
* - If current thread is interrupted, throw InterruptedException.
*
- Save lock state returned by {@link #getState}.
*
- Invoke {@link #release} with saved state as argument,
* throwing IllegalMonitorStateException if it fails.
*
- Block until signalled or interrupted.
*
- Reacquire by invoking specialized version of
* {@link #acquire} with saved state as argument.
*
- If interrupted while blocked in step 4, throw InterruptedException.
*
*/
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);
}
首先用addConditionWaiter()方法把这个线程包装成Node并放入condition queue。
2.addConditionWaiter()：加入condition等待队列。
/**
* 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;
}
新建包装当前线程的node。找到condition队列中没有被cancel的lastWaiter，然后把当前Node设为lastWaiter。
3.fullyRelease(node):释放当前state值。并返回释放前的值。
/**
* Invokes release with current state value; returns saved state.
* Cancels node and throws exception on failure.
* @param node the condition node for this wait
* @return previous sync state
*/
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;
}
}
4.release(savedState):tryRelease(arg)调用释放锁资源:
/**
* Releases in exclusive mode. Implemented by unblocking one or
* more threads if {@link #tryRelease} returns true.
* This method can be used to implement method {@link Lock#unlock}.
*
* @param arg the release argument. This value is conveyed to
* {@link #tryRelease} but is otherwise uninterpreted and
* can represent anything you like.
* @return the value returned from {@link #tryRelease}
*/
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
5.unparkSuccessor(h):叫醒syn queue中沉睡的线程：找到头结点后第一个没有被cancel的节点，然后对这个节点包装的线程执行unpark()操作
/**
* Wakes up node's successor, if one exists.
*
* @param node the node
*/
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
}
await()操作总结：
1.新建包装当前线程的node放到condition waiting queue中去。
2.释放此节点的锁资源。
3.找到syn queue中头节点后第一个没被cancel的节点并叫醒这个节点沉睡的线程。
4.对当前线程进行park();
二. signal():首先这个线程获取到了锁资源，然后执行signal()操作，把condition queue 中的第一个节点删除，并把这个节点放入syn queue
调用图:
1.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);
}
对condition queue 第一个节点进行唤醒。
2.doSignal(first):从队头找，找到第一个非空节点进行节点迁移。
/**
* Removes and transfers nodes until hit non-cancelled one or
* null. Split out from signal in part to encourage compilers
* to inline the case of no waiters.
* @param first (non-null) the first node on condition queue
*/
private void doSignal(Node first) {
do {
if ( (firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
first.nextWaiter = null;
} while (!transferForSignal(first) &&
(first = firstWaiter) != null);
}
3.transferForSignal(Node node):把当前节点从condition queue 迁移到sync queue 中。
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;
}
先调用enq(node);把节点放到sync queue 的队尾，同时unpark 当前线程，这时这个线程又获得了竞争锁资源的资格。