Java多线程进阶（6）—— J.U.C之locks框架：AQS独占功能剖析(2)

最新推荐文章于 2024-08-05 16:35:43 发布
最新推荐文章于 2024-08-05 16:35:43 发布
阅读量794 收藏 28
点赞数 19
分类专栏： java并发 文章标签： java java并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smart_an/article/details/136146341
版权

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

阶段2、深入多线程设计模式

阶段3、深入juc源码解析


阶段4、深入jdk其余源码解析


阶段5、深入jvm源码解析

码哥源码部分

码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】

码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】

码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】

​​​​​​码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】

码哥源码-原理源码篇【Doug Lea为什么要将成员变量赋值给局部变量后再操作？】

码哥讲源码【你水不是你的错,但是你胡说八道就是你不对了！】

码哥讲源码【谁再说Spring不支持多线程事务，你给我抽他！】

终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！

打脸系列【020-3小时讲解MESI协议和volatile之间的关系，那些将x86下的验证结果当作最终结果的水货们请闭嘴】

一、本章概述

本章以ReentrantLock的调用为例，说明AbstractQueuedSynchronizer提供的独占功能。
本章结构如下：

  1. 以ReentrantLock的公平策略为例，分析AbstractQueuedSynchronizer的独占功能
  2. 以ReentrantLock的非公平策略为例，分析AbstractQueuedSynchronizer的独占功能
  3. 分析AbstractQueuedSynchronizer的锁中断、限时等待等功能

二、ReentrantLock的公平策略原理

本节对ReentrantLock公平策略的分析基于以下示例：

假设现在有3个线程：ThreadA、ThreadB、ThreadC，一个公平的独占锁，3个线程会依次尝试去获取锁：ReentrantLock lock=new ReentrantLock(true);

线程的操作时序如下：

    
    //ThreadA    lock
    
    //ThreadB    lock
    
    //ThreadC    lock
    
    //ThreadA    release
    
    //ThreadB    release
    
    //ThreadC    release

2.1 ThreadA首先获取到锁

ThreadA首先调用ReentrantLock的 lock 方法，我们看下该方法的内部：

最终其实调用了FairSync的lock方法：

acquire 方法来自AQS：

其中 tryAcquire 方法需要AQS的子类自己去实现，我们来看下ReentrantLock中的实现：

可以看到，在ReentrantLock中，同步状态State的含义如下：

State资源的定义
0表示锁可用
1表示锁被占用
大于1表示锁被占用，且值表示同一线程的重入次数

ThreadA是首个获取锁的线程，所以上述方法会返回true，第一阶段结束。（ThreadA一直保持占有锁的状态）
此时，AQS中的等待队列还是空：

2.2 ThreadB开始获取锁

终于，ThreadB要登场了，一样，ThreadB先去调用lock方法，最终调用AQS的acquire方法：

tryAcquire 方法肯定是返回false（因为此时ThreadA占有着锁）。
接下来看下 addWaiter 方法，这个方法其实就是将当前调用线程包装成一个【独占结点】，添加到等待队列尾部。

这里关键是enq方法，因为并发插入的情况存在，所以该方法设计成了自旋操作，保证结点能成功插入，具体步骤如下：
①当队列为空的时候，先创建一个dummy头结点；

②进入下一次循环，插入队尾结点。

好了，ThreadB已经被包装成结点插入队尾了，接下来会调用 acquireQueued 方法，这也是AQS中最重要的方法之一：

在AQS中，等待队列中的线程都是阻塞的，当某个线程被唤醒时，只有该线程是首结点（线程）时，才有权去尝试获取锁。

上述方法中，将ThreadB包装成结点插入队尾后，先判断ThreadB是否是首结点（注意不是头结点，头结点是个dummy结点），发现确实是首结点（node.predecessor==head），于是调用tryAcquire尝试获取锁，但是获取失败了（此时ThreadA占有着锁），就要判断是否需要阻塞当前线程。

判断是否需要阻塞线程：

注意，对于独占功能，只使用了3种结点状态：

结点状态值描述
CANCELLED1取消。表示后驱结点被中断或超时，需要移出队列
SIGNAL-1发信号。表示后驱结点被阻塞了（当前结点在入队后、阻塞前，应确保将其prev结点类型改为SIGNAL，以便prev结点取消或释放时将当前结点唤醒。）
CONDITION-2Condition专用。表示当前结点在Condition队列中，因为等待某个条件而被阻塞了

对于在等待队列中的线程，如果要阻塞它，需要确保将来有线程可以唤醒它，AQS中通过将前驱结点的状态置为SIGNAL:-1来表示将来会唤醒当前线程，当前线程可以安心的阻塞。

看下图或许比较好理解：
①插入完ThreadB后，队列的初始状态如下：

②虽然ThreadB是队首结点，但是它拿不到锁（被ThreadA占有着），所以ThreadB会阻塞，但在阻塞前需要设置下前驱的状态，以便将来可以唤醒我：

至此，ThreadB的执行也暂告一段落了（安心得在等待队列中睡觉）。

注意：补充一点，如果ThreadB在阻塞过程中被中断，其实是不会抛出异常的，只会在acquireQueued方法返回时，告诉调用者在阻塞器件有没被中断过，具体如果处理，要不要抛出异常，取决于调用者，这其实是一种延时中断机制。

2.3 ThreadC开始获取锁

终于轮到ThreadC出场了，ThreadC的调用过程和ThreadB完全一样，同样拿不到锁，然后加入到等待队列队尾：

然后，ThreadC在阻塞前需要把前驱结点的状态置为SIGNAL：-1，以确保将来可以被唤醒：

至此，ThreadC的执行也暂告一段落了（安心得在等待队列中睡觉）。

2.4 ThreadA释放锁

ThreadA终于使用完了临界资源，要释放锁了，来看下ReentrantLock的 unlock 方法：

unlock内部调用了AQS的release方法，传参1：

尝试释放锁的操作 tryRelease ：

释放成功后，调用 unparkSuccessor 方法，唤醒队列中的首结点：

此时，队列状态为：

2.5 ThreadB唤醒后继续执行

好了，队首结点（ThreadB）被唤醒了。
ThreadB会继续从以下位置开始执行，先返回一个中断标识，用于表示ThreadB在阻塞期间有没被中断过：

然后ThreadB又开始了自旋操作，被唤醒的是队首结点，所以可以尝试tryAcquire获取锁，此时获取成功（ThreadA已经释放了锁）。
获取成功后会调用setHead方法，将头结点置为当前结点，并清除线程信息：

最终的队列状态如下：

2.6 ThreadB释放锁

ThreadB也终于使用完了临界资源，要释放锁了，过程和ThreadA释放时一样，释放成功后，会调用 unparkSuccessor 方法，唤醒队列中的首结点：

队首结点（ThreadC）被唤醒后，继续从原来的阻塞处向下执行，并尝试获取锁，获取成功，最终队列状态如下：

2.7 ThreadC释放锁

ThreadC也终于使用完了临界资源，要释放锁了。释放成功后，调用unparkSuccessor方法，唤醒队列中的首结点：
此时队列中只剩下一个头结点（dummy），所以这个方法其实什么都不做。最终队列的状态就是只有一个dummy头结点。

至此，AQS的独占功能已经差不多分析完了，剩下还有几个内容没分析：

  1. 锁中断功能
  2. 限时等待功能
  3. Conditon等待功能

这些功能将在后续章节陆续分析。

三、ReentrantLock的非公平策略原理

ReenrantLock非公平策略的内部实现和公平策略没啥太大区别：
非公平策略和公平策略的最主要区别在于：

  1. 公平锁获取锁时，会判断等待队列中是否有线程排在当前线程前面。只有没有情况下，才去获取锁，这是公平的含义。

  2. 非公平锁获取锁时，会立即尝试修改同步状态，失败后再调用AQS的acquire方法。


    acquire方法会转调非公平锁自身的tryAcquire方法，其实最终是调了nofairTryAcquire方法，而该方法相对于公平锁，只是少了“队列中是否有其它线程排在当前线程前”这一判断：

四、AQS对中断的支持

还是以ReentrantLock为例，来看下AQS是如何实现锁中断和超时的。

我们知道ReentrantLock的 lockInterruptibly 方法是会响应中断的。（线程如果在阻塞过程中被中断，会抛出InterruptedException异常）

该方法调用了AQS的 acquireInterruptibly 方法：

上述代码会先去尝试获取锁，如果失败，则调用doAcquireInterruptibly方法，如下：

很眼熟有木有？看下和 acquireQueued 方法的对比，唯一的区别就是：
当调用线程获取锁失败，进入阻塞后，如果中途被中断， acquireQueued 只是用一个标识记录线程被中断过，而 doAcquireInterruptibly 则是直接抛出异常。

五、AQS对限时等待的支持

Lock接口中有一个方法： tryLock ，用于在指定的时间内尝试获取锁，获取不到就返回。
ReentrantLock实现了该方法，可以看到，该方法内部调用了AQS的 tryAcquireNanos 方法：

tryAcquireNanos 方法是响应中断的，先尝试获取一次锁，失败则调用 doAcquireNanos 方法进行超时等待：

关键是 doAcquireNano 方法，和 acquireQuqued 方法类似，又是一个自旋操作，在超时前不断尝试获取锁，获取不到则阻塞（加上了等待时间的判断）。该方法内部，调用了LockSupport.parkNanos来超时阻塞线程：

LockSupport.parkNanos内部其实通过Unsafe这个类来操作线程的阻塞，底层是一个native方法：

如果当前线程在指定时间内获取不到锁，除了返回false外，最终还会执行 cancelAcquire 方法：

示例

为了便于理解还是以3个线程为例：

假设现在有3个线程：ThreadA、ThreadB、ThreadC，一个公平的独占锁，3个线程会依次尝试去获取锁，不过此时加上了限时等待：ThreadB等待10s，ThreadA等待20s。

    ReentrantLock lock=new ReentrantLock(true);
    
    //ThreadA    tryLock
    
    //ThreadB    tryLock, 10s
    
    //ThreadC    tryLock, 20s
    
    //ThreadA    release
    
    //ThreadB    release
    
    //ThreadC    release

1. ThreadA首先获取到锁，ThreadB和ThreadC依次尝试去获取锁
ThreadB和ThreadC经过两轮自旋操作后，等待队列的情况如下：

2. ThreadB先到超时时间
调用了 cancelAcquire 方法取消操作，队列状态变成：

3. ThreadC到达超时时间
调用了 cancelAcquire 方法取消操作，队列状态变成：

在退出 cancelAcquire 后，原来ThreadB和ThreadC对应的结点会被JVM垃圾回收器回收。

六、总结

本章从ReentrantLock入手，分析AQS的独占功能的内部实现细节。下一章，从CountDownLatch入手，看下AQS的共享功能如何实现。

smart哥
关注
专栏目录
吃透Java并发十：locks之AQS独占锁功能分析
吃透Java
01-29 302
一、独占锁代表ReentrantLock ReentrantLock类，实现了Lock接口，是一种可重入的独占锁，它具有与使用 synchronized 相同的一些基本行为和语义，但功能更强大。ReentrantLock内部通过内部类实现了AQS框架(AbstractQueuedSynchronizer)的API来实现独占锁的功能。 ReentrantLock中有一个抽象类Sync继承AQS，它的...
AQS(AbstractQueuedSynchronizer)中获取与释放锁分析
qq_37803406的博客
01-25 346
说明：本文是我对自己学习知识的一个简单总结，可能存在许多不足，我希望通过此方式来回顾知识，加强理解，也希望大家能指出文中的错误与不足，互相学习，谢谢。 AQS(AbstractQueuedSynchronizer)核心分析 首先看一下类图： AbstractOwnableSynchronizer是个抽象类，以独占模式设置当前持有的线程。 AbstractQueuedSynchronizer...
【Java并发编程实战】-----“J.U.C”：AQS分析（二）：获取锁、释放锁
chenssy 的技术博客
12-24 6184
上篇博客稍微介绍了一下AQS，下面我们来关注下AQS的所获取和锁释放。AQS锁获取AQS包含如下几个方法：acquire(int arg)：以独占模式获取对象，忽略中断。acquireInterruptibly(int arg)： 以独占模式获取对象，如果被中断则中止。acquireShared(int arg)： 以共享模式获取对象，忽略中断。acquireSharedInterruptibly
AQS（一）：互斥锁的加锁和锁的释放流程
最新发布
liang8999的博客
08-05 676
release方法是AQS中互斥锁 释放锁的入口，在该方法中通过调用子类的tryRelease() 方法。该方法的作用是：线程节点node已经存在于AQS队列中，调用该方法判断 是否将node关联。该方法作用是把 当前线程节点添加到AQS队列中，每次都把新创建的Node节点添加到。该方法作用是 取消AQS阻塞队列中的节点node，使node后续不再进锁资源的竞争。SHARED =共享的节点（共享锁）注意：当前node节点是活跃节点（即持有锁的节点）且node一定是头节点。
逐行分析AQS源码(2)——独占锁的释放
weixin_34234829的博客
07-24 276
前言 系列文章目录 上一篇文章 我们逐行分析了独占锁的获取操作, 本篇文章我们来看看独占锁的释放。如果前面的锁的获取流程你已经趟过一遍了, 那锁的释放部分就很简单了, 这篇文章我们直接开始看源码. 开始之前先提一句, JAVA的内置锁在退出临界区之后是会自动释放锁的, 但是ReentrantLock这样的显式锁是需要自己显式的释放的,...
多线程系列学习：AQS（二）释放锁
qiuxinfa123的博客
04-15 241
前面一篇文章写了如何获取锁：多线程系列学习：AQS（一）获取锁，下面以unlock()方法为入口，看看AQS如何释放锁： public void unlock() { sync.release(1); } 接着看release()方法： public final boolean release(int arg) { if (tryRelease(arg)) { Node h = head; if
AQS源码解读——释放锁
岁月流逝
08-14 366
ReentrantLock的公平锁和非公平锁的释放锁的逻辑从源码层面上来看是相同的，我们直接看ReentrantLock的unlock()方法： 调用了sync内部类的release()，Sync对于父类AQS的release()并未重写，走到了AQS中： tryRelease(arg)也是一个模板方法，由子类来实现： 最终走到ReentrantLock的tryRelease()： 这块就是ReentrantLock的释放锁逻辑： 在释放锁的时候，先给state值减1，并且当前线程必须是持有锁的线程
Java多线程进阶—— J.U.C之locks框架：StampedLock
浅汐
12-12 225
一、StampedLock类简介 StampedLock类，在JDK1.8时引入，是对读写锁ReentrantReadWriteLock的增强，该类提供了一些功能，优化了读锁、写锁的访问，同时使读写锁之间可以互相转换，更细粒度控制并发。 首先明确下，该类的设计初衷是作为一个内部工具类，用于辅助开发其它线程安全组件，用得好，该类可以提升系统性能，用不好，容易产生死锁和其它莫名其妙的问题。 1....
Java并发编程进阶——并发锁
行者无疆的博客
03-14 4274
1 JAVA 多线程锁介绍 1.1 悲观锁 定义：悲观锁指对数据被外界修改持保守态度，认为数据很容易就会被其他线程修改（很悲观），所以在数据被处理前先对数据进行加锁，并在整个数据处理过程中，使数据处于锁定状态。 悲观锁的实现：开发中常见的悲观锁实现往往依靠数据库提供的锁机制，即在数据库中，在对数据记录操作前给记录加排它锁。如果获取锁失败，则说明数据正在被其他线程修改，当前线程则等待或者抛出异常。如果获取锁成功，则对记录进行操作，然后提交事务后释放排它锁。 实例：Java 中的 synchronized 关键
java多线程与线程池-04线程池与AQS
天空鸟的博客
03-10 634
java.util.concurrent包中的绝大多数同步工具，如锁（locks）和屏障（barriers）等，都基于AbstractQueuedSynchronizer（简称AQS）构建而成。这个框架提供了一套同步管理的通用机制，如同步状态的原子性管理、线程阻塞与解除阻塞，还有线程排队等。
【Java多线程】JUC之深入队列同步器(AQS)（三）自定义AQS组件-独占锁(上)
墩墩分墩
12-26 552
**AQS同步器的主要实现方式是`继承`，子类通过`继承AQS同步器`并 `实现它的抽象方法` 来管理`同步状态state`** - 对于使用者来讲，我们无需关心**获取资源失败，线程排队，线程阻塞/唤醒等一系列复杂的实现**，这些都在AQS中为我们处理好了。我们只需要负责好自己的那个环节就好，也就是**获取/释放共享资源state的姿势**T_T。 - 很经典的`模板方法设计模式`的应用，AQS为我们定义好`顶级逻辑的骨架`，并提取出`公用的线程入队列/出队列，阻塞/唤醒等一系列复杂逻辑的实现`，将
AQS系列（四）- ReentrantReadWriteLock读写锁的释放锁
终极冥帝
12-21 201
前言 继续JUC包中ReentrantReadWriteLock的学习，今天学习释放锁。 一、写锁释放锁 入口方法 1 public void unlock() { 2 sync.release(1); 3 } 进入AQS追踪release方法： 1 public final boolean release(int a...
java释放锁_【Java并发编程实战】- AQS(二)：获取锁、释放锁 - Java 技术驿站-Java 技术驿站...
weixin_32514497的博客
02-20 269
上篇博客稍微介绍了一下AQS，下面我们来关注下AQS的所获取和锁释放。AQS锁获取AQS包含如下几个方法：acquire(int arg)：以独占模式获取对象，忽略中断。acquireInterruptibly(int arg)： 以独占模式获取对象，如果被中断则中止。acquireShared(int arg)： 以共享模式获取对象，忽略中断。acquireSharedInterruptibly...
Java并发编程--AQS的锁获取和释放
Mr long的博客
07-09 402
/** * acquire(int arg)：以独占模式获取对象，忽略中断。 acquireInterruptibly(int arg)： 以独占模式获取对象，如果被中断则中止。 acquireShared(int arg)： 以共享模式获取对象，忽略中断。 acquireSharedInterruptibly(int arg)以共享模式获取对象...
AQS 释放锁源码浅析
善雪博客
05-23 563
head节点一定是拿到锁的节点 head后继的尝试获取资源的节点 其他节点都是阻塞的 回顾简单的入队方法 //创建节点 和waitting模式 //cas快速添加到队尾 失败进入enq循环添加 private Node addWaiter(Node mode) { .... enq(node); .... } //入队操作...
JUC之五：AQS共享锁的获取和释放（Semaphore代码解析）
zhengguofeng0328的博客
03-05 704
文章目录共享锁与独占锁的区别Semaphore内部类共享锁的获取setHeadAndPropagate执行doReleaseShared的条件共享锁的释放同时执行doReleaseShared总结 共享锁与独占锁的区别 共享锁在同一时刻多个线程占有锁，独占锁同一时刻只能有一个线程占有锁，并把线程放在exclusiveOwnerThread成员上。 共享锁与独占锁都需要被唤醒。 共享锁唤醒线程有两种方式：  1、在唤醒线程的同时，该线程也会尝试唤醒后面的线程（在setHeadAndPropagate方法
AQS-公平锁锁逻辑与释放锁逻辑--个人笔记
weixin_43470959的博客
03-26 106
公平锁逻辑与释放锁逻辑 锁逻辑 final void lock() { acquire(1); } 调用lock方法时实际调用的是acquire()方法 public final void acquire(int arg) { //tryAcquire(arg)尝试去获取锁 if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterr
AQS源码解析（五）
weixin_38910645的博客
12-12 138
Condition条件锁实现（二） public final void await() throws InterruptedException { // if (Thread.interrupted()) { // throw new InterruptedException(); // } else { // AbstractQueuedSynchroni...
java-AQS源码学习-响应中断的lock
Cia_zibo的博客
08-17 743
AQS-响应中断的lock 前文:AQS源码学习 在lock中, 我们有响应中断处理和不响应中断处理的lock, 而在日常使用中, 经常使用的是不响应的.lock操作 本文就来学习一下, 在aqs中是如何做到响应线程interrupt的获取锁操作的 public final void acquireInterruptibly(int arg) throws InterruptedException { // 在尝试获取之前判断线程异常状态 // 这里的
J.U.C线程安全理论与编程实践讲解
资源摘要信息:"本文档主要讨论了Java并发编程中J.U.C（Java.util.concurrent）包的相关内容，特别是围绕线程安全的理论和编程技术。J.U.C是Java平台提供的一个用于编写并发程序的工具包，它包含了一系列的并发构建块...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值