AQS源码解读(六)——从PROPAGATE和setHeadAndPropagate()分析共享锁的传播性

三、acquireShared获取共享锁


共享锁除了可以多个线程共享外,在共享节点间还具有传播性。何为传播性,先看共享锁获取锁的代码:

//java.util.concurrent.locks.AbstractQueuedSynchronizer#acquireShared

public final void acquireShared(int arg) {

//tryAcquireShared 返回-1获取锁失败,返回值大于1或者0获取锁成功

if (tryAcquireShared(arg) < 0)

//获取锁失败,进入队列操作

doAcquireShared(arg);

}

tryAcquireSharedReentrantReadWriteLock中的实现,返回值只有两种,1表示获取锁成功,-1表示获取锁失败。在SemaphoretryAcquireShared的返回值代表资源剩余量,返回值大于等于0表示获取锁成功,小于0表示获取锁失败。

四、doAcquireShared进入同步队列操作


tryAcquireShared获取锁失败后,进入AQS同步队列操作doAcquireShared。创建共享节点node,并CAS排到队列尾部,接下来判断是应该阻塞还是继续获取锁。当node的前驱节点是head时,尝试获取锁tryAcquireShared,如果获取锁成功返回值r >= 0,则执行函数setHeadAndPropagate,这个函数就是共享锁的传播性。

//java.util.concurrent.locks.AbstractQueuedSynchronizer#doAcquireShared

private void doAcquireShared(int arg) {

//创建一个读节点,并入队列

final Node node = addWaiter(Node.SHARED);

boolean failed = true;

try {

boolean interrupted = false;

for (;😉 {

final Node p = node.predecessor();

if (p == head) {

//如果前继节点是head,则尝试获取锁

int r = tryAcquireShared(arg);

if (r >= 0) {

//获取锁成功,设置新head和共享传播(唤醒后继共享节点)

setHeadAndPropagate(node, r);

p.next = null; // help GC

if (interrupted)

selfInterrupt();

failed = false;

return;

}

}

/**

  • p不是头结点 or 获取锁失败,判断是否应该被阻塞

  • 前继节点的ws = SIGNAL 时应该被阻塞

*/

if (shouldParkAfterFailedAcquire(p, node) &&

parkAndCheckInterrupt())

interrupted = true;

}

} finally {

if (failed)

cancelAcquire(node);

}

}

五、setHeadAndPropagate共享锁的传播性


node获取锁成功出队,设置新head,并将共享性传播给后继节点,即唤醒后继共享节点。为什么当一个节点的线程获取共享锁后,要唤醒后继共享节点?共享锁是可以多个线程共有的,当一个节点的线程获取共享锁后,必然要通知后继共享节点的线程,也可以获取锁了,这样就不会让其他等待的线程等很久,而传播性的目的也是尽快通知其他等待的线程尽快获取锁。

private void setHeadAndPropagate(Node node, int propagate) {

Node h = head; // Record old head for check below

//设置node为新head

setHead(node);

/*

  • The conservatism in both of these checks may cause

  • unnecessary wake-ups, but only when there are multiple

  • racing acquires/releases, so most need signals now or soon

  • anyway.

*/

// propagate > 0,短路后面的判断

if (propagate > 0 || h == null || h.waitStatus < 0 ||

(h = head) == null || h.waitStatus < 0) {

//唤醒后继共享节点

Node s = node.next;

if (s == null || s.isShared())

doReleaseShared();

}

}

setHeadAndPropagate中调用doReleaseShared前需要一连串的条件判断,大概可以分为三部分:

1. propagate > 0

ReentrantReadWriteLock中走到setHeadAndPropagate,只可能是propagate > 0,所以后面判断旧、新head的逻辑就被短路了。

而在Semaphore中走到setHeadAndPropagatepropagate是可以等于0的,表示没有剩余资源了,故propagate > 0不满足,往后判断。

2. h == null || h.waitStatus < 0

首先判断旧head是否为null,一般情况下是不可能是等于null,除非旧head刚好被gc了。h == null不满足,继续判断h.waitStatus < 0h.waitStatus可能等于0,可能等于-3。

  • h.waitStatus=0的情况,某个线程释放了锁(release or releaseShared)或者前一个节点获取共享锁传播setHeadAndPropagate,唤醒后继节点的时候将h.waitStatus=-1设置为0。

  • h.waitStatus=-3doReleaseShared唤醒head后继节点后h.waitStatus从-1到0,还没来得及更新head,即被唤醒的共享节点还没有setHeadAndPropagate,又有其他线程doReleaseShared唤醒head后继节点h.waitStatus从0到-3。

//java.util.concurrent.locks.AbstractQueuedSynchronizer#unparkSuccessor

private void unparkSuccessor(Node node) {

int ws = node.waitStatus;

if (ws < 0)

//cas设置h.waitStatus -1 --> 0

compareAndSetWaitStatus(node, ws, 0);

//唤醒后继节点的线程,若为空or取消了,从tail往后遍历找到一个正常的节点

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)

//uppark线程

LockSupport.unpark(s.thread);

}

当释放共享锁or共享锁传播后会调用doReleaseShared唤醒同步队列中head的后继节点。

首先明确几个判断:

  • h.waitStatus = Node.SIGNALcompareAndSetWaitStatus(h, Node.SIGNAL, 0))unparkSuccessor

  • h.waitStatus = 0compareAndSetWaitStatus(h, 0, Node.PROPAGATE)设置head为传播模式。

  • h == head,head没有变,break中断循环;也可能被唤醒的节点立刻获取了锁出队列,导致head变了,所以继续循环唤醒head后继节点。

//java.util.concurrent.locks.AbstractQueuedSynchronizer#doReleaseShared

private void doReleaseShared() {

for (;😉 {

Node h = head;

if (h != null && h != tail) {

int ws = h.waitStatus;

if (ws == Node.SIGNAL) {

//SIGNAL --> 0

if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))

continue; // loop to recheck cases

//唤醒后继节点的线程

unparkSuccessor(h);

}

else if (ws == 0 &&

//0 --> PROPAGATE

!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))

continue; // loop on failed CAS

}

/**

  • we must loop in case a new node is added

  • while we are doing this

*/

if (h == head) // loop if head changed

//head没有变则break

break;

}

}

3. (h = head) == null || h.waitStatus < 0

首先判断新head是否为空,一般情况下新head不为空,(h = head) == null不满足,判断h.waitStatus < 0h.waitStatus可能等于0,可能小于0(-3 or -1)。

  • h.waitStatus可能等于0的情况,后继节点刚好入队列,还没有走到shouldParkAfterFailedAcquire()中的修改前继节点waitStatus的代码。

  • h.waitStatus=-3,上一个共享节点被唤醒后,成为新head,后继节点刚入队列,又有其他线程释放锁调用doReleaseSharedh.waitStatus从0改为-3。

  • h.waitStatus=-1,已经调用了shouldParkAfterFailedAcquire()h.waitStatus从0 or -3 改为-1,可能阻塞,可能未阻塞。

//java.util.concurrent.locks.AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {

int ws = pred.waitStatus;

if (ws == Node.SIGNAL)

/*

  • This node has already set status asking a release

  • to signal it, so it can safely park.

  • node拿锁失败,前继节点的状态是SIGNAL,node节点可以放心的阻塞,

  • 因为下次会被唤醒

*/

return true;

if (ws > 0) {

/*

  • Predecessor was cancelled. Skip over predecessors and

  • indicate retry.

  • pred节点被取消了,跳过pred

do {

node.prev = pred = pred.prev;

} while (pred.waitStatus > 0);

pred.next = node;

} else {

/* 0 -3

  • waitStatus must be 0 or PROPAGATE. Indicate that we

  • need a signal, but don’t park yet. Caller will need to

  • retry to make sure it cannot acquire before parking.

*/

compareAndSetWaitStatus(pred, ws, Node.SIGNAL);

}

return false;

}

六、举例求证共享锁传播性


接下来通过控制变量法,求证共享锁的传播性。

对于ReentrantReadWriteLock,既然走到了setHeadAndPropagatetryAcquireShared返回值就一定大于0,即propagate > 0,所以对于ReentrantReadWriteLockPROPAGATE只是一个中间状态值,即使没有PROPAGATE也不会影响共享锁的传播性。

Semaphore具有资源的概念,走到setHeadAndPropagatetryAcquireShared返回值代表资源剩余量,返回值可能等于0,所以需要配合状态PROPAGATE完成共享锁的传播性。

接下来只讨论Semaphore的传播情况。

(1)假设Semaphore有10个资源都被占用。A线程获取资源失败入队列阻塞。此时C释放资源,唤醒A(h.ws=-1 ---> h.ws=0)。A获取资源成功,但是没有资源了,tryAcquireShared返回0(p=0)。此时B线程获取资源失败进入队列,但是还没有阻塞(A.ws=0)。

p>0不满足,h==null || h.ws < 0 不满足,h=head==null || h.ws < 0不满足。都不满足,A线程执行setHeadAndPropagate不唤醒B线程,因为没有资源了,没必要唤醒。

(2)在(1)的基础上,当判断完3个条件后,D线程释放资源,B还没有阻塞,B也无需被D唤醒,B在阻塞前还有一次重试的机会;在D释放资源前,B已经阻塞了,就由D唤醒B。

最后

自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。

深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。

既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Java开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!

如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!

由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
24年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。**

[外链图片转存中…(img-kYFh77HB-1715616379475)]

[外链图片转存中…(img-12pYLP5c-1715616379476)]

[外链图片转存中…(img-Js2EHP7j-1715616379476)]

既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Java开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!

如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!

由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!

  • 23
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值