jdk源码解读-并发包-Lock-ReentrantLock(2)--await()与signal()方法走读

本人知乎技术文章

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. * * <p>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}. * * <p>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. * <ol> * <li> If current thread is interrupted, throw InterruptedException. * <li> Save lock state returned by {@link #getState}. * <li> Invoke {@link #release} with saved state as argument, *      throwing IllegalMonitorStateException if it fails. * <li> Block until signalled or interrupted. * <li> Reacquire by invoking specialized version of *      {@link #acquire} with saved state as argument. * <li> If interrupted while blocked in step 4, throw InterruptedException. * </ol> */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 当前线程，这时这个线程又获得了竞争锁资源的资格。