throw new InterruptedException();
//只有小于0的时候才会加入同步等待队列
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
private Node addWaiter(Node mode) {
Node node = new Node(mode);
for (;😉 {
Node oldTail = tail;
//尾节点不为空说明已经初始化过了
if (oldTail != null) {
//Unsafe.putObject(Object o, int offset, Object x)
//设置node的前驱节点为oldTail
U.putObject(node, Node.PREV, oldTail);
if (compareAndSetTail(oldTail, node)) {
//oldTail的后继节点设置为node
oldTail.next = node;
return node;
}
} else {
//初始化同步队列,头尾节点都是指向同一个新的Node实例
initializeSyncQueue();
}
}
}
private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
//创建一个共享模式的节点,添加到队列中
final Node node = addWaiter(Node.SHARED);
try {
for (;😉 {
//返回当前节点的前驱节点
final Node p = node.predecessor();
if (p == head) {
//返回1不再阻塞,出队,-1仍然继续阻塞
int r = tryAcquireShared(arg);
if (r >= 0) {
//往下翻一下,有分析
setHeadAndPropagate(node, r);
p.next = null;
return;
}
}
//往下翻一下,有分析
if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()){
throw new InterruptedException();
}
}
} catch (Throwable t) {
//往下翻一下,有分析
cancelAcquire(node);
throw t;
}
}
/**
-
设置同步等待队列的头节点,判断当前处理的节点的后继节点是否共享模式的节点,
-
如果共享模式的节点,propagate大于0或者节点的waitStatus为PROPAGATE
-
则进行共享模式下的释放资源
*/
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head;
//设置node为头节点
setHead(node);
//propagate大于0 || 头节点为null || 头节点的状态为非取消 || 再次获取头节点为null || 再次获取头节点的状态为非取消
if (propagate > 0 || h == null || h.waitStatus < 0 || (h = head) == null || h.waitStatus < 0) {
Node s = node.next;
//后继节点==null或者是共享模式的节点
if (s == null || s.isShared())
doReleaseShared();//往上翻,上面分析过了
}
}
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
//前驱节点状态设置成Node.SIGNAL成功,等待被release调用释放,后继节点可以安全地进入阻塞状态
return true;
if (ws > 0) {
do {
node.prev = pred = pred.prev;
//waitStatus大于0,表示前驱节点已经取消
} while (pred.waitStatus > 0);
//找到一个非取消的节点,重新通过next引用连接当前共享模式的节点
pred.next = node;
} else {
//前驱节点非取消状态,全部设置为Node.SIGNAL
pred.compareAndSetWaitStatus(ws, Node.SIGNAL);
}
return false;
}
// 阻塞当前线程,获取并且重置线程的中断标记位
private final boolean parkAndCheckInterrupt() {
//来了来了,关键的方法:阻塞线程的实现,依赖Unsafe的API
LockSupport.park(this);
return Thread.interrupted();
}
我们再看一下cancelAcquire(node)
里面做了什么:
// java.util.concurrent.locks.AbstractQueuedSynchronizer
private void cancelAcquire(Node node) {
if (node == null)
return;
//此时节点的线程已经中断取消,置空节点的线程
node.thread = null;
Node pred = node.prev;
//(跳过取消状态的节点)获取当前节点的上一个非取消状态的节点
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
//保存node.prev非取消状态节点的后继节点
Node predNext = pred.next;
//更新当前节点状态=取消
node.waitStatus = Node.CANCELLED;
// 如果当前节点是尾节点,将当前节点的上一个非取消状态的节点设置为尾节点
// 更新失败的话,则进入else,如果更新成功,将tail的后继节点设置为null
if (node == tail && compareAndSetTail(node, pred)) {
pred.compareAndSetNext(predNext, null);
} else {
int ws;
// 如果当前节点不是head的后继节点
// 1:判断当前节点前驱节点的是否为SIGNAL,
// 2:如果不是,则把前驱节点设置为SINGAL看是否成功
// 如果1和2中有一个为true,再判断当前节点的线程是否为null
// 如果上述条件都满足,把当前节点的前驱节点的后继指针指向当前节点的后继节点
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && pred.compareAndSetWaitStatus(ws, Node.SIGNAL))) &&
pred.thread != null) {
Node next = node.next;
if (next != null && next.waitStatus <= 0)
pred.compareAndSetNext(predNext, next);
} else {
//上述条件不满足,唤醒当前节点的后继节点
unparkSuccessor(node);
}
node.next = node;// help GC
}
}
private void unparkSuccessor(Node node) {
// 获取头节点waitStatus
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
// 获取当前节点的下一个节点
Node s = node.next;
// 如果下个节点是null或者下个节点被cancelled,就找到队列最开始的非cancelled的节点
if (s == null || s.waitStatus > 0) {
s = null;
// 就从尾部节点开始找,到队首,找到队列第一个waitStatus<0的节点。
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
// 如果当前节点的下个节点不为空,而且状态<=0,就把当前节点unpark
if (s != null)
LockSupport.unpark(s.thread);
}
cancelAcquire()
调用的地方:
1.主动中断
2.
acquire
过程中发生异常
3.超时版本的API调用的时候剩余超时时间小于等于零的时候
cancelAcquire()
主要作用是把取消的节点移出同步等待队列,满足上面代码里面分析的条件,会进行后继节点的唤醒unparkSuccessor(node)
5.聊聊LockSupport如何实现阻塞和解除阻塞的?
先看看下面几个代码片段:
//示例一:
Log.d(TAG,“001”)
LockSupport.park(this)
Log.d(TAG,“002”)
输出:
001
阻塞中…
//示例二:
LockSupport.unpark(Thread.currentThread())
Log.d(TAG,“001”)
LockSupport.park(this)
Log.d(TAG,“002”)
…
Log.d(TAG,“执行完”)
输出:
001
002
执行完
//示例三:
val thread = Thread.currentThread()
cacheThreadPool.execute{
Log.d(TAG,“一个耗时的异步任务,正在执行…”)
Thread.sleep(1500)
//提供许可,解除阻塞
LockSupport.unpark(thread)
}
Log.d(TAG,“001”)
//阻塞当前线程
LockSupport.park(this)
Log.d(TAG,“002”)
…
Log.d(TAG,“执行完”)
输出:
001
一个耗时的异步任务,正在执行…
002
执行完
看了上面的示例,是不是懂了?🙈🙈
LockSupport的park
方法有两个:
//java.util.concurrent.locks.LockSupport
public static void park(Object blocker) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
U.park(false, 0L);
setBlocker(t, null);
}
public static void park() {
U.park(false, 0L);
}
/**
-
通过反射机制获取Thread类的parkBlocker字段对象。
-
然后通过sun.misc.Unsafe对象的objectFieldOffset方法,
-
获取到parkBlocker在内存里的偏移量
*/
private static void setBlocker(Thread t, Object arg) {
U.putObject(t, PARKBLOCKER, arg);
}
static {
PARKBLOCKER = U.objectFieldOffset
(Thread.class.getDeclaredField(“parkBlocker”));
}
用谁?还用疑问🤔吗?当然推荐大家使用有参数的park(blocker)
方法啦。
我们看一下点击查看Thread源码里面的parkBlocker
:
/**
-
The argument supplied to the current call to
-
java.util.concurrent.locks.LockSupport.park.
-
Set by (private) java.util.concurrent.locks.LockSupport.setBlocker
-
Accessed using java.util.concurrent.locks.LockSupport.getBlocker
*/
volatile Object parkBlocker;
parkBlocker
对象是用来记录线程被阻塞是被谁阻塞的,用于线程监控和分析工具来定位原因的。
LockSupport通过getBlocker
获取到阻塞的对象,主要用于监控和分析线程。
park阻塞、unpark解除阻塞,最终会调用UnSafe
内部对应的native方法
的实现
三、使用场景
1.ARouter加载指定包名下class集合的用法
//com.alibaba.android.arouter.utils.ClassUtils
fun getFileNameByPackageName():Set{
val classNames: Set = HashSet()
val paths = getSourcePaths(context)
val parserCtl = CountDownLatch(paths.size())
for (path in paths) {
DefaultPoolExecutor.getInstance().execute{
try{
//耗时的加载数据…
}finnaly{
parserCtl.countDown()
}
}
}
parserCtl.await()
return classNames
}
2.假设有三个线程:A/B/C,我们在A/B完成或者部分完成的时候启动C
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此我收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点!不论你是刚入门Android开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。**
深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此我收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-I3DgdqW9-1715506471890)]
[外链图片转存中…(img-8S5ufXaO-1715506471892)]
[外链图片转存中…(img-7YnS8edf-1715506471893)]
[外链图片转存中…(img-5JOZP9Wr-1715506471894)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点!不论你是刚入门Android开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!