阅读AQS -- AbstractQueuedSynchronizer源码

最新推荐文章于 2023-04-26 14:32:27 发布
最新推荐文章于 2023-04-26 14:32:27 发布
阅读量107 收藏
点赞数
分类专栏： 源码 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sparrowxin/article/details/108551863
版权

阅读AQS -- AbstractQueuedSynchronizer源码

什么是AQS?

具体的类位于 : java.util.concurrent.locks.AbstractQueuedSynchronizer

AQS是基于FIFO等待队列的，用来实现阻塞锁和相关同步机制的框架, 比如信号量(semaphroe), 事件(events), 可重入读写锁之类的,都是用这个实现的。其内部是使用原子int来表示状态的。子类需要覆盖其中的protected方法来实现同步机制。

AQS同时支持排他模式和共享模式。排他模式情况下，如果一个线程已经有锁了，其他线程是无法获取到锁的。共享模式则其他线程可能可以获取到锁。AQS本身不理解这些模式，而是需要开发人员在实现类中决定，在已经有线程获取到锁的情况下，正在等待的下一个线程应不应该获取到锁。

用法

需要重写以下方法

  • tryAcquire
  • tryRelease
  • tryAcquireShared
  • tryReleaseShared
  • isHeldExclusively

具体用

  • 用 getState 获取当前的状态,
  • 用 setState 或 compareAndSetState 更新当前的状态

这些方法默认的实现是抛出异常 UnsupportedOperationException, 同时要注意重写的时候应该是线程安全,并且通常很简短且非阻塞。重写这些方法是唯一的使用方式，其他的方法都被声明为了final，因为他们都是相互关联的（一个方法的调用涉及到其他的方法调用，才能保证代码实现想要的效果）所以随便改可能会出bug。

核心的同步机制主要是以下形式

获取锁：

while (!tryAcquire(arg)) {//尝试获取锁
   //获取失败的时候
   //如果线程还未入队列则入队列
   //根据需要可以阻塞当前线程
}

释放锁：

if (tryRelease(arg)) { //如果释放锁成功
	//唤醒等待队列中的第一个线程
}

共享模式是类似的,不过可能涉及到级联唤醒, 也就是说可能需要唤醒队列中多个等待中的线程

Node

等待队列是CLH(Craig, Landin, 和 Hagersten)锁队列的变体。CLH锁通常用于自旋锁。当前节点保存了其后继节点的控制信息。其中的status变量标识了一个线程是否要被阻塞。当一个节点的前驱节点被释放的时候，它会被通知（signaled）。队列中的每个节点表示某种特定通知类型的监视器，持有一个等待队列。但是status成员变量不控制线程是否会获取到锁。头结点不代表就一定会获取锁，只是说有机会去竞争锁而已。

入队列就是队列尾添加一个节点，出队列就是直接获取头结点。

         +------+  prev +-----+       +-----+
    head |      | <---- |     | <---- |     |  tail
         +------+       +-----+       +-----+

插入队列只需要对 tail 节点进行一个原子操作， 所以会有简单的原子点界定未入队列和已入队列，类似的，出队列涉及到 head 节点的操作。然后，为了确定节点的后继节点，需要额外的工作，部分是因为要处理由于超时或者中断导致的取消。

“pre” 指针是 CLH 队列原来没有的, 主要是用来处理取消逻辑的. 如果一个节点被取消了,需要把其后继节点连接到要取消节点的前驱节点(就是链表删除节点的逻辑)

“next” 指针用来实现阻塞机制, 每个节点都保存了thread id， 所以前驱节点根据 next 指向的节点来决定唤醒哪个线程。

整体的思路

以 java.util.concurrent.locks.ReentrantLock.Sync 为例可以看看AQS是怎么工作的, Sync 是是一个抽象类, 继承子AQS, 本身只留下 lock 一个方式未实现。

AQS内部有一个变量 state

  • state = 0 的时候,表示锁没有被获取,可以加锁
  • state 大于 0 的时候, 表示某个线程持有了锁(ownerThread)

注: state是被声明为 volatile 的, 但是 ownerThread 不需要是volatile的, 因为代码里面是判断了 state > 0 才会去使用 ownerThread.

加锁(state + acquires)

acquire 是一个 int 值, 从参数传过来的, (比如 ReentrantLock 里面用的是 1)

  1. 首先判断是否是未锁定状态 (state = 0)
  2. 如果是未锁定状态(state = 0), 则使用 CAS 操作更新 state 为 acquires, 如果成功, 则认为是获取锁成功, 保存当前线程为 ownerThread ; 如果获取失败, 则入队列并挂起, 等待唤醒
  3. 如果是已经锁定的状态(state > 0), 则判断当前线程是不是 ownerThread, 如果是的话, 更新 state = state + acquires, 这也就意味着, 锁是可以重入的, 而且加锁了几次,就需要释放(state - acquires)几次,这样才能使 state 回到 0, 也就是为加锁的状态
  4. 实现上是调用 AQS.acquire(args), 伪代码如下
function AQS.acquire(args) {
	(! tryAcquire(args)) && 入队列
}

function lock(args) {
	AQS.acquire(args)
}


上述截图代码是给非公平锁用的, 因为公平锁还需要判断队列中是否有等待的线程

释放(state - release)

release是一个 int 值, 从参数传过来的, (比如 ReentrantLock 里面用的是 1)

  1. 判断当前线程是否是 ownerThread,如果不是的话, 抛IllegalMonitorStateException 异常
  2. 更新 state = state - acquires, 如果 state 为 0, 则更新 ownerThread 为 null, 并出队列

在这里插入图片描述

获取非公平锁

以 java.util.concurrent.locks.ReentrantLock.NonfairSync 为例

直接使用CAS更新 state, 更新成功就设置 ownThread 为自己, 否则就调用上面的 AQS.acquire(args), 其中就包含了入队列的逻辑

在这里插入图片描述

获取公平锁

以 java.util.concurrent.locks.ReentrantLock.FairSync 为例

相比于获取非公平锁的简单粗暴, 一上来就直接CAS state, 公平锁会先去判断队列中是否有等待的线程,如果有的话,就不进行CAS尝试, 除非已经持有锁, 否则会将当前线程入等待队列.

在这里插入图片描述

AbstractQueuedSynchronizer 的方法

获取共享锁

acquireShared

acquireShared
调用 tryAcquireShared ，如果小于0 （也就是没有没有成功获取到锁）， 则调用 doAcquireShared

tryAcquireShared (等待子类实现的protected方法)

尝试去获取共享锁, 这个方法应该检查当前对象的状态是否允许获取锁, 允许了才去获取锁。

线程会调用这个方法去获取共享锁，如果获取锁失败（返回值为负数或者抛异常），那么线程会被入队列（如果还没有入队列的话）直到被其他线程唤醒。

tryAcquireShared 是 protected 的，需要子类去实现，默认是抛出 UnsupportedOperationException 异常。

返回值int类型,

  • 负数表示获取失败
  • 0 表示获取锁成功，但是后续的获取共享锁会失败
  • 1 表示获取锁成功，后续的获取共享锁可能会成功，这种情况下需要检查后续线程的有效性

doAcquireShared (执行获取锁的逻辑,同时负责更新队列)

在这里插入图片描述

流程说明
1. 把node添加到链表的最后（addWaiter），然后开始循环：
1.1 获取节点的前驱，如果前驱是 head 节点，则调用 tryAcquireShared
1.1.1 返回值大于等于 0 则说明获取成功了，那就把当前节点作为头头结点并设置 r （ setHeadAndPropagate(node, r)）,这意味着把前驱节点也就是之前的头结点出队列了,当前节点变成了头结点，然后跳出循环
1.2 前驱不是头结点或者头结点尝试获取锁失败，调用 shouldParkAfterFailedAcquire 检查是否应该挂起
1.2.1 如果前一个节点的waitStatus为Node.SIGNAL（-1）， 则直接返回true， 应该挂起；
1.2.2 如果前一个节点的waitStatus大于0 ，也即是 Node.CANCEL（1）或其他， 则循环去掉前面所有WaitStatus大于 0 的链表的节点， 然后返回false， 不挂起
1.2.3 如果前一个节点的waitStatus小于0 但是不是 Node.SIGNAL，则应该是 0 或者 PROPAGATE， 表示应该至少唤醒1次，使用cas把节点的状态改成 Node.SIGNAL， 然后返回false不挂起
1.3 如果应该挂起,则调用 parkAndCheckInterrupt(), 其中调用了LockSupport.park(thread) 挂起队列,然后返回 thread.interrupted() 状态, 改变了循环里面的变量, 从而通过调用 selfInterrupt 用另一种方式跳出了循环.

addWaiter(Node mode)

参数mode是选择独占还是共享,常量在Node类中定义。
tail不为空的时候，首先尝试cas插入到tail后面(所谓的 fast path), 如果失败了或者tail为空则调用 enq进行循环cas。

enq（Node node）

新节点入队列，如果tail为null， 则head也是为null， 所以直接设置 tail 和 head 为新的节点(new Node 而不是参数的那个)， 使用的是cas操作；如果tail不为null，则在末尾插入参数的node（也是cas操作）。然后进行循环直到节点入队列成功。返回值返回的是原来的tail节点而不是参数中的node。

释放共享锁

在这里插入图片描述

releaseShared

在这里插入图片描述
共享模式下的释放锁, 如果 tryReleaseShared返回true, 则可能会取消阻塞1个或多个线程。

tryReleaseShared

同样需要子类去实现， 返回是 boolean，如果允许释放则返回true， 否则返回false

doReleaseShared

共享模式下的释放 – 唤醒后继节点并确保Propagation(传播)
在这里插入图片描述

0. 进入循环
1. 如果头节点的状态是 Signal (-1)的话, 尝试更新Signal为0
1.1 如果更新成功, 则调用 unparkSuccessor 唤醒 head 节点的下一个节点;
1.2 如果更新waitStatus失败,则说明有其他线程修改了head的状态,则重新循环(continue)
2. 否则如果头结点的状态是 0 的话, 尝试更新为 Propagate, 如果失败,则重新循环.
3. 如果循环开始时候的获取的 head 和 现在的 head 节点是同一个的话, 则结束循环, 否则继续循环。因为循环的过程中可能头结点已经被其他线程改变了,所以如果被改变的话,需要重新循环。

unparkSuccessor(node)

唤醒node节点的后继节点,如果存在的话。如果node的waitStatus小于0 ，则设置为0（0表示未被锁定）。一般来说要唤醒的节点就是node的后继节点，但是节点有可能被取消获取为null，所以要从tail往前去找到实际的未被取消的后继节点。
唤醒调用的是 LockSupport.unpark(s.thread);
在这里插入图片描述

waitStauts小于0的情况是有以下3种waitStatus小于0的情况

独占锁

获取独占锁

在这里插入图片描述
调用 tryAcquire 方法, 这个方法是子类实现的,默认是抛异常, 如果失败了的话, 线程入队列

aquireQueued (独占模式的线程入队列)

在这里插入图片描述
直接开始循环, 如果新加节点的前驱节点是 head 节点, 则再次尝试获取锁(因为前驱是头结点的话, 说明下一个要唤醒的就是自己了,头结点本身不保存线程); 如果前驱不是头结点, 或 是头结点但是获取锁失败, 则检查是否应该挂起, 这部分和获取共享模式那里是一样的。

释放独占锁

在这里插入图片描述
调用 tryRelease, 如果成功, 则唤醒头结点的后继节点.

lock,tryLock,lockInterruptibly 的区别

A线程已经获取到锁的情况下, B线程尝试获取锁

方法返回值是否阻塞阻塞期间线程中断(调用interrupte)
lockvoid是不抛异常
lockInterruptiblyvoid是抛异常
tryLockboolean否无
tryLock(time)boolean最多阻塞time时间抛异常

todo

ConditionObject 是什么?

todo

readObject ？

这个类序列化的时候,只能保存原子状态变量, 反序列化之后的类Thread队列都会丢失。子类需要实现readObject方法来将其还原到初始状态。

todo

hasQueuedPredecessors?

专门给公平锁用的
todo

如何实现公平锁 (todo)

冲突(Barging)

因为获取锁操作是在入队列之前, 所以一个新的要来获取锁的线程可能会和已经在队列中等待的线程抢锁, 所以可能导致不公平。为了实现公平机制，通常可以重写 tryAcquire 或/和 tryAquireShared , 让其在hasQueuedPredecessors （一个专门为公平锁设计的方法） 返回 true 的时候, 返回false。

acquireSharedInterruptibly

如果Thread.interrupted 为true,抛出 InterruptedException 异常，然后调用 tryAcquireShared(arg) ， 如果小于 0 （没有获取到锁） 则调用 doAcquireSharedInterruptibly(arg);
在这里插入图片描述

simba lin
关注
专栏目录
谈谈synchronized 和 ReentrantLock 的区别？
CYK_byte的博客
09-26 857
synchronized和ReentrantLock都是Java中的可重入锁；
JUC学习 - AbstractQueuedSynchronizer源码解读（AQS）
TyuIn的博客
12-03 565
一、AbstractQueuedSynchronizer的认识 AbstractQueuedSynchronizer抽象队列同步器简称AQS，它是实现同步器的基础组件，juc下面Lock的实现以及一些并发工具类就是通过AQS来实现的。 AQS会把所有的请求线程构成一个CLH队列，当一个线程执行完毕（lock.unlock()）时会激活自己的后继节点，但正在执行的线程并不在队列中，而那些等待执行的线程全部处于阻塞状态(park())。【关于CLH队列的描述，参考：https://blog.csdn.net/f
synchronized 和 ReentrantLock 区别是什么？
weixin_43758730的博客
09-18 135
synchronized 和 ReentrantLock 区别是什么？ synchronized 竞争锁时会一直等待；ReentrantLock 可以尝试获取锁，并得到获取结果 synchronized 获取锁无法设置超时；ReentrantLock 可以设置获取锁的超时时间 synchronized 无法实现公平锁；ReentrantLock 可以满足公平锁，即先等待先获取到锁 synchronized 控制等待和唤醒需要结合加锁对象的 wait() 和 notify()、notifyAll()；Reen
Synchronized和ReentrantLock有什么区别
wxmgcs的专栏
06-09 468
直接上代码 import org.junit.Test; import java.util.concurrent.locks.ReentrantLock; public class ThreadSafeSample { public int sharedState1; public int sharedState2; public int sharedState3...
synchronized 和 ReentrantLock 有什么区别
最新发布
雪雪
04-26 121
9.Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用synchronized 时， 等待的线程会一直等待下去，不能够响应中断。2.ReentrantLock 可响应中断、可轮回，synchronized 是不可以响应中断的，为处理锁的不可用性提供了更高的灵活性。6.底层实现不一样， synchronized 是同步阻塞，使用的是悲观并发策略，lock 是同步非阻塞，采用的是乐观并发策略。2.都是可重入锁，同一线程可以多次获得同一个锁。3.都保证了可见性和互斥性。
60. synchronized 和 ReentrantLock 区别是什么？
zhu_fangyuan的博客
11-30 604
synchronized 是关键字，ReentrantLock 是类，这是二者的本质区别。既然ReentrantLock 是类，那么它提供了比 synchronized 更多更灵活的特性，可以被继承，可以有方法，可以有各种各样的类变量。 synchronized 早期的实现比较低效，对比 ReentrantLock ，大多数场景性能都相差较大，但是在 JDK1.6 中对 synchronized 进行了非常多的改进。 相同点：两者都是可重入锁 两者都是可重入锁。 “可重入锁”概念是：自己可以再次获取自.
AQS源码解析之AbstractQueuedSynchronizer类
AbstractQueuedSynchronizer（AQS）是Java并发包中一个重要的基础类，用于实现同步器的底层机制。AQS提供了一种可重入的互斥锁和其他同步组件的实现方式。 AQS的主要特点包括： - 状态管理：AQS内部维护了一个32位...
JUC学习 - AbstractQueuedSynchronizer源码解读（AQS）（补）
TyuIn的博客
12-03 355
接上一篇博客 https://blog.csdn.net/qq_43605444/article/details/121705312?spm=1001.2014.3001.5501 3、release(int) 方法 release(int)方法是独占模式下线程释放共享资源的顶层入口。它会释放指定量的资源，如果彻底释放了（即state=0）,它会唤醒等待队列里的其他线程来获取资源。这也正是unlock()的语义，当然不仅仅只限于unlock()。下面是release()的源码： /** *
AQS源码阅读笔记,画了两三天的AQS...
06-29
AQS源码阅读笔记 AQS（AbstractQueuedSynchronizer）是Java并发编程中的一种同步器框架，它提供了一个队列来管理线程的排队和唤醒机制。下面是AQS源码阅读笔记的详细解释： 1. `ReentrantLock` 的 `unlock()` 方法...
JUC 系列：AQS --＞学习 Doug Lea 大神思想
weixin_44936189的博客
09-08 412
AQS：全称是AbstractQueuedSynchronizer，一个并发同步管理框架类，是 JUC 的灵魂抽象类。如果要自己去实现一个同步管理框架呢？ 个人学习寒食君大佬的解析后觉得可以分为三点： 通用性，下层实现透明的同步机制，同时给上层提供业务代码编写的功能 利用 CAS 操作，原子的修改共享标志位（由这个标志位来判断共享资源是否空闲） 等待队列（埋伏笔：情况①：当共享资源被占用时，直接返回结果、情况②：当共享资源被占用时，让后续的线程进入到等待队列中等待） 与 AQS 的结构有着异曲同工之妙，
ReentrantLock与synchronized区别
03-02
java语言 并发编程 ReentrantLock与synchronized区别 详解
惠农电子超市（SpringCloud+Redis+Nginx+MySQL+Elasticsearch+RabbitMQ）
09-21
该项目是类似于淘宝，京东的网上购物系统。用户可以进行用户登录注册、商品游览、将商品加入购物车、添加订单等功能。
21.synchronized 和 ReentrantLock 区别是什么？
面试题库
07-11 82
《synchronized 和 reentrantlock 区别是什么_面试官：谈谈synchronized与ReentrantLock的区别？》：https://blog.csdn.net/weixin_39714565/article/details/111365743
java多线程入门笔记，包括线程安全
weixin_43975276的博客
11-06 114
多线程的创建， 方式一：继承于 hread类（只能单继承） 1.创建一个继承于 Thread类的子类 2.重写Thread类的run（）–>将此线程执行的操作声明在run（）中 3.创建 Thread类的子类的对象 通过此对象调用 start（） 想要共享数据需要将数据设置为静态 创建多线程的方式二：实现 Runnable接口 1.创建一个实现了 Runnable接口的类 2.实现类去实现 Runnable中的抽象方法：run（） 创建实现类的对象 4.将此对象作为参数传递到 Thread类的构造器中
常用的线程池有（4种）
LiJianGuo_Mr的博客
10-14 540
常用的线程池有哪些 newSingleThreadExecutor：创建一个单线程的线程池，此线程池保证所有任务的执行顺序 按照任务的提交顺序执行。 newFixedThreadPool：创建固定大小的线程池，每次提交一个任务就创建一个线程，直到 线程达到线程池的最大大小。 newCachedThreadPool：创建一个可缓存的线程池，此线程池不会对线程池大小做限制，线 程池大小完全依赖于操作系统（或者说 JVM）能够创建的最大线程大小。 newScheduledThreadPool：创建一个大小无限的线
synchronized 和 reentrantlock 区别是什么_Synchronized与ReentrantLock区别总结
weixin_39958137的博客
12-10 70
相似点：这两种同步方式有很多相似之处，它们都是加锁方式同步，而且都是阻塞式的同步，也就是说当如果一个线程获得了对象锁，进入了同步块，其他访问该同步块的线程都必须阻塞在同步块外面等待，而进行线程阻塞和唤醒的代价是比较高的(操作系统需要在用户态与内核态之前来回切换，代价很高，不过可以通过对锁优化来进行改善)。功能区别：这两种方式最大的区别就是对于Synchronized来说，它是Java语言的关键字，...
synchronized和ReenTrantLock有什么区别和联系？
weixin_39309402的博客
05-29 474
synchronized是Java内建的同步机制，它提供了互斥的语义和可见性，当一个线程已经获取当前的锁时，其他试图获取的线程只能等待或者阻塞在那里。ReentrantLock和synchronized类似，都是可重入锁，但是ReentrantLock内部有提供了许多方法，使用起来相对灵活，比如需要通过.lock()实现加锁，通过.unlock()释放锁，不然会一直上锁。 synchronized和ReenTrantLock都是可重入锁 可重入锁：自己可以再次获取自己的内部锁就叫可重入锁。比如线程A获得了
synchronized 和 reentrantlock 区别是什么_面试官：谈谈synchronized与ReentrantLock的区别？...
weixin_39714565的博客
11-27 118
工作与面试中经常会遇到Java常见的加锁方法，本文着重介绍synchronized与ReentrantLock的区别。① 底层实现上来说，synchronized 是JVM层面的锁，是Java关键字，通过monitor对象来完成（monitorenter与monitorexit），对象只有在同步块或同步方法中才能调用wait/notify方法，ReentrantLock 是从jdk1.5以来（j...
JUC源码系列之ReentrantLock源码解析
死牛胖子的技术随笔
12-14 153
目录 ReentrantLock 简介 ReentrantLock 使用示例 ReentrantLock 与 synchronized 的区别 ReentrantLock 实现原理 ReentrantLock 源码解析 ReentrantLock 简介 ReentrantLock 是 JDK 提供的一个可重入的独占锁， 独占锁：同一时间只有一个线程可以持有锁 可重入：持有锁的线程可重复加锁，意味着第一次成功加锁时，需要记录锁的持有者为当前线程，后续再次加锁时，可以识别当前线程。 ReentrantL
深入解析Java AQS独占模式：AbstractQueuedSynchronizer源码详解
本文将深入解析Java并发编程中的关键组件——`AbstractQueuedSynchronizer (AQS)` 的源码，特别是独占模式部分。在上一篇博客中，作者概述了AQS的基本结构，包括排队区的实现、独占和共享模式的概念，以及节点的等待...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值