JDK源码分析-AbstractQueuedSynchronizer(3)

概述


前文「JDK源码分析-AbstractQueuedSynchronizer(2)」分析了 AQS 在独占模式下获取资源的流程,本文分析共享模式下的相关操作。


其实二者的操作大部分是类似的,理解了前面对独占模式的分析,再分析共享模式就相对容易了。


共享模式


方法概述


与独占模式类似,共享模式下也有与之类似的相应操作,分别如下:


1. acquireShared(int arg): 以共享模式获取资源,忽略中断;


2. acquireSharedInterruptibly(int arg): 以共享模式获取资源,响应中断;


3. tryAcquireSharedNanos(int arg, long nanosTimeout): 以共享模式获取资源,响应中断,且有超时等待;


4. releaseShared(int arg): 释放资源,唤醒后继节点,并确保传播


它们的操作与独占模式也比较类似,下面具体分析。


方法分析


1. 共享模式获取资源(忽略中断)


acquireShared:

public final void acquireShared(int arg) {// 返回值小于 0,表示获取失败    if (tryAcquireShared(arg) < 0)        doAcquireShared(arg);}

// 尝试以共享模式获取资源(返回值为 int 类型)protected int tryAcquireShared(int arg) {    throw new UnsupportedOperationException();}

与独占模式的 tryAcquire 方法类似,tryAcquireShared 方法在 AQS 中也抛出异常,由子类实现其逻辑。


不同的地方在于,tryAcquire 方法的返回结果是 boolean 类型,表示获取成功与否;而 tryAcquireShared 的返回结果是 int 类型,分别为:

1) 负数:表示获取失败;

2) 0:表示获取成功,但后续共享模式的获取会失败;

3) 正数:表示获取成功,后续共享模式的获取可能会成功(需要进行检测)。


tryAcquireShared 获取成功,则直接返回;否则执行 doAcquireShared 方法:

private void doAcquireShared(int arg) {    // 把当前线程封装成共享模式的 Node 节点,插入主队列末尾    final Node node = addWaiter(Node.SHARED);    boolean failed = true;    try {        // 中断标志位        boolean interrupted = false;        for (;;) {            final Node p = node.predecessor();            // 若前驱节点为头节点,则尝试获取资源            if (p == head) {                int r = tryAcquireShared(arg);                // 这里表示当前线程成功获取到了资源                if (r >= 0) {                    // 设置头节点,并传播状态(注意这里与独占模式不同)                    setHeadAndPropagate(node, r);                    p.next = null; // help GC                    if (interrupted)                        selfInterrupt();                    failed = false;                    return;                }            }            // 是否应该休眠(与独占模式相同,不再赘述)            if (shouldParkAfterFailedAcquire(p, node) &&                parkAndCheckInterrupt())                interrupted = true;        }    } finally {        if (failed)            // 取消操作(与独占模式相同)            cancelAcquire(node);    }}

doAcquireShared 方法会把当前线程封装成一个共享模式(SHARED)的节点,并插入主队列末尾。addWaiter(Node mode) 方法前文已经分析过,不再赘述。


该方法与 acquireQueued 方法的区别在于 setHeadAndPropagate 方法,把当前节点设置为头节点之后,还会有传播(propagate)行为:

private void setHeadAndPropagate(Node node, int propagate) {    // 记录旧的头节点    Node h = head; // Record old head for check below    // 将 node 设置为头节点    setHead(node);    /*     * Try to signal next queued node if:     *   Propagation was indicated by caller,     *     or was recorded (as h.waitStatus either before     *     or after setHead) by a previous operation     *     (note: this uses sign-check of waitStatus because     *      PROPAGATE status may transition to SIGNAL.)     * and     *   The next node is waiting in shared mode,     *     or we don't know, because it appears null     *     * The conservatism in both of these checks may cause     * unnecessary wake-ups, but>     * racing acquires/releases, so most need signals now or soon     * anyway.     */    if (propagate > 0 || h == null || h.waitStatus < 0 ||        (h = head) == null || h.waitStatus < 0) {        Node s = node.next;        // 后继节点为空或共享模式唤醒        if (s == null || s.isShared())            doReleaseShared();    }}

doReleaseShared:

private void doReleaseShared() {    /*     * Ensure that a release propagates, even if there are other     * in-progress acquires/releases.  This proceeds in the usual     * way of trying to unparkSuccessor of head if it needs     * signal. But if it does not, status is set to PROPAGATE to     * ensure that upon release, propagation continues.     * Additionally, we must loop in case a new node is added     * while we are doing this. Also, unlike other uses of     * unparkSuccessor, we need to know if CAS to reset status     * fails, if so rechecking.     */    for (;;) {        // 这里的头节点已经是上面设置后的头节点了        Node h = head;        // 由于该方法有两个入口(setHeadAndPropagate 和 releaseShared),需考虑并发控制        if (h != null && h != tail) {            int ws = h.waitStatus;            if (ws == Node.SIGNAL) {                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))                    continue;            // loop to recheck cases                // 唤醒后继节点                unparkSuccessor(h);            }            else if (ws == 0 &&                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))                continue;                // loop>        }        // 若头节点不变,则跳出循环;否则继续循环        if (h == head)                   // loop if head changed            break;    }}

该方法与独占模式下的获取方法 acquire 大体相似,不同在于该方法中,节点获取资源后会传播状态,即,有可能会继续唤醒后继节点。值得注意的是:该方法有两个入口 setHeadAndPropagate 和 releaseShared,可能有多个线程操作,需考虑并发控制。


此外,本人对于将节点设置为 PROPAGATE 状态的理解还不是很清晰,网上说法也不止一种,待后续研究明白再补充。


2. 以共享模式获取资源(响应中断)


该方法与 acquireShared 类似:

public final void acquireSharedInterruptibly(int arg)        throws InterruptedException {    if (Thread.interrupted())        throw new InterruptedException();    if (tryAcquireShared(arg) < 0)        doAcquireSharedInterruptibly(arg);}

tryAcquireShared 方法前面已分析,若获取资源失败,则会执行 doAcquireSharedInterruptly 方法:

private void doAcquireSharedInterruptibly(int arg)    throws InterruptedException {    // 把当前线程封装成共享模式节点,并插入主队列    final Node node = addWaiter(Node.SHARED);    boolean failed = true;    try {        for (;;) {            final Node p = node.predecessor();            if (p == head) {                int r = tryAcquireShared(arg);                if (r >= 0) {                    setHeadAndPropagate(node, r);                    p.next = null; // help GC                    failed = false;                    return;                }            }            // 与 doAcquireShared 相比,区别在于这里抛出了异常            if (shouldParkAfterFailedAcquire(p, node) &&                parkAndCheckInterrupt())                throw new InterruptedException();        }    } finally {        if (failed)            cancelAcquire(node);    }}

从代码可以看到,acquireSharedInterruptibly 方法与 acquireShared 方法几乎完全一样,不同之处仅在于前者会抛出 InterruptedException 异常响应中断;而后者仅记录标志位,获取结束后才响应。


3. 以共享模式获取资源(响应中断,且有超时)


代码如下(该方法可与前文独占模式下的超时获取方法比较分析)

public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)        throws InterruptedException {    if (Thread.interrupted())        throw new InterruptedException();    return tryAcquireShared(arg) >= 0 ||        doAcquireSharedNanos(arg, nanosTimeout);}

doAcquireSharedNanos: 

private boolean doAcquireSharedNanos(int arg, long nanosTimeout)        throws InterruptedException {    if (nanosTimeout <= 0L)        return false;    final long deadline = System.nanoTime() + nanosTimeout;    final Node node = addWaiter(Node.SHARED);    boolean failed = true;    try {        for (;;) {            final Node p = node.predecessor();            if (p == head) {                int r = tryAcquireShared(arg);                if (r >= 0) {                    setHeadAndPropagate(node, r);                    p.next = null; // help GC                    failed = false;                    return true;                }            }            nanosTimeout = deadline - System.nanoTime();            if (nanosTimeout <= 0L)                return false;            if (shouldParkAfterFailedAcquire(p, node) &&                nanosTimeout > spinForTimeoutThreshold)                LockSupport.parkNanos(this, nanosTimeout);            if (Thread.interrupted())                throw new InterruptedException();        }    } finally {        if (failed)            cancelAcquire(node);    }}

该方法可与独占模式下的超时等待方法 tryAcquireNanos(int arg, long nanosTimeout) 进行对比,二者操作基本一致,不再详细分析。


4. 释放资源,唤醒节点,传播状态


如下:

public final boolean releaseShared(int arg) {    if (tryReleaseShared(arg)) {        doReleaseShared();        return true;    }    return false;}

tryReleaseShared:

protected boolean tryReleaseShared(int arg) {    throw new UnsupportedOperationException();}

doReleaseShared() 方法前面已经分析过了。本方法与独占模式的 release 方法类似,不同的地方在于“传播”二字。


场景分析


为了便于理解独占模式和共享模式下队列和节点的状态,下面简要举例分析。

场景如下:有 T0~T4 共 5 个线程按先后顺序获取资源,其中 T2 和 T3 为共享模式,其他均为独占模式。


就此场景分析:T0 先获取到资源(假设占用时间较长),而后 T1~T4 再获取则失败,会依次进入主队列。此时主队列中各个节点的状态示意图如下:


之后,T0 操作完毕并释放资源,会将 T1 唤醒。T1(独占模式) 会从 acquireQueued(final Node node, int arg) 方法的循环中继续获取资源,这时会获取成功,并将 T1 设置为头节点(T 被移除)。此时主队列节点示意图如下:

此时,T1 获取到资源并进行相关操作。


而后,T1 操作完释放资源,并唤醒下一个节点 T2,T2(共享模式) 继续从 doAcquireShared(int) 方法的循环中执行。此时 T2 获取资源成功,将自身设为头节点(T1 被移除),由于后继节点 T3 也是共享模式,因此 T1 会继续唤醒 T3;T3 唤醒后的操作与 T2 相同,但后继节点 T4 不是共享模式,因此不再继续唤醒。此时队列节点状态示意图如下:

此时,T2 和 T3 同时获取到资源。


之后,当二者都释放资源后会唤醒 T4:

T4 获取资源的与 T1 类似。


PS: 该场景仅供参考,只为便于理解,若有不当之处敬请指正。


小结


本文分析了以共享模式获取资源的三种方式,以及释放资源的操作。分别为:


1. acquireShared: 共享模式获取资源,忽略中断;

2. acquireSharedInterruptibly: 共享模式获取资源,响应中断;

3. tryAcquireSharedNanos: 共享模式获取资源,响应中断,有超时;

4. releaseShared: 释放资源,唤醒后继节点,并确保传播。


并简要分析一个场景下主队列中各个节点的状态。此外,AQS 中还有嵌套类 ConditionObject 及条件队列的相关操作,后面涉及到的时候再进行分析。


单独去分析 AQS 的源码比较枯燥,后文会结合 ReentrantLock、CountdownLatch 等常用并发工具类的源码进行分析。


上述解析是参考其他资料及个人理解,若有不当之处欢迎指正。


相关阅读:

JDK源码分析-AbstractQueuedSynchronizer(2)

JDK源码分析-AbstractQueuedSynchronizer(1)



Stay hungry, stay foolish.

猜你喜欢

转载自juejin.im/post/5d5561b3e51d4561cb5dde88
0条评论
添加一条新回复
  
今日推荐