AQS源码解读

已于 2024-10-12 14:08:44 修改
阅读量486 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 源码分析 Java 文章标签： java AQS
于 2023-08-19 12:05:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/liangsheng_g/article/details/132376673

文章目录

前言

AQS是AbstractQueuedSynchronizer的缩写，也是大神Doug Lea的得意之作。今天我们来进行尽量简化的分析和理解性的代码阅读。
来个示意图

一、AQS是什么？

其实从全称翻译来看，我们其实可以判断出AQS的作用，排队的同步器，或者翻译为“使同步器排队”。所以它的主要作用就是使得线程通过排队的方式进行同步。

二、解读

重点属性

state

state变量是一个volatile的变量，同时内部提供了普通的读写操作，加一个通过Unsafe实现的CAS更写state的方法。CAS更新变量的方法其实就是为了保证对于state变量的更新是线程安全的。

protected final boolean compareAndSetState(int expect, int update) {
   
   
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

head、tail

既然是队列，那必然要有头尾节点，我们的头尾节点的类型是一个内部类-Node

static final class Node {
   
   
        /** Marker to indicate a node is waiting in shared mode */
        static final Node SHARED = new Node();
        /** Marker to indicate a node is waiting in exclusive mode */
        static final Node EXCLUSIVE = null;

        /** waitStatus value to indicate thread has cancelled */
        static final int CANCELLED =  1;
        /*
最低0.47元/天 解锁文章

200万优质内容无限畅学
AQS 源码解读之解锁
Sdj356512265的博客
03-20 552
在 AQS 源码解读之加锁中，线程 A 占用着锁没有释放。然后线程 B 和线程 C 都在 CHL 队列中排队，也就是执行了 parkAndCheckInterrupt 方法将自己挂起了。现在 CHL 队列的状态： 线程 A unlock() 方法解析 ReentrantLock 类中的 unlock 方法 public void unlock() { sync.release(1); } sync 类中的 release 方法 public final boolean rele
一文带你了解 AQS 源码分析
lt_xiaodou的博客
10-12 1271
AQS，就是AbstractQueuedSynchronizer，在同步组件的实现中，AQS是核心部分，同步组件的实现者通过使用AQS提供的模板方法实现同步组件语义，AQS则实现了等等一些底层的实现处理。，而这些实际上则是AQS提供出来的模板方法，归纳整理如下：AbstractQueuedSynchronizer 的AbstractQueuedSynchronizer 的。
AQS 源码解读
小毕超博客
03-07 963
AQS不做具体的某个场景的应用，但通过其内部维护的FIFO队列和共享资源state便可以实现很多种不同的场景，在阅读了AQS源码后，应该有了更深入的理解，后面再去看等的源码会发现很容易理解。
AQS源码详细解读
qq_24428851的博客
08-21 897
AQS源码解读，带你逐行逐句解读AQS源码，最全面的解析，看完这篇文章吊打面试官！！！
JUC并发编程AQS源码解读
西岭千秋雪的博客
04-05 1133
JUC个人学习笔记
Java AQS源码解读
gongpulin的博客
01-21 480
https://juejin.im/post/5e0b79886fb9a048381921e4?utm_source=gold_browser_extension
AQS源码解读（七）——ReentrantReadWriteLock原理详解（读写锁是一把锁吗
2401_84692110的博客
05-10 809
MAX_COUNT即是写锁的重入最大次数的界限，也是持有读锁的读线程的最大数量的界限。作为写锁重入次数的掩码，但是感觉duck不必，写锁状态位本身是低位的，（）再与作运算得到写锁重入次数，不还是原值c吗？强调一点，写线程获取锁修改state，就是正常的+1，可以理解为低16位+1；而读线程获取锁修改state，是高16位+1，即为每次是一个很大数，每次读锁state加这么大个数，怎么是+1呢，这里就要理解高16位+1是在二进制下+1:四、锁的公平性ReadLock和WriteLock。
图文讲解AQS源码
皮球
02-28 375
图文讲解AQS源码
科普文：JUC系列之AQS源码解读其实现原理
为无为，事无事，味无味。
08-05 1024
AQS全称为AbstractQueuedSynchronizer，它提供了一个FIFO（First in First out 先入先出）队列，可以看成是一个用来实现同步锁以及其他涉及到同步功能的核心组件，常见的有:ReentrantLock、CountDownLatch等。
AQS源码解读（番外篇）——四种自旋锁原理详解（Java代码实现SpinLock、TicketSpinLock、CLH、MCS
2303_77877769的博客
05-10 607
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
AQS源码解读：从ReentrantLock到Semaphore的底层实现
Java中的并发包（java.util.concurrent）提供了一些常用的工具类来解决这些问题，其中最重要的一种就是AQS（AbstractQueuedSynchronizer）。 AQS是Java并发包中用于构建锁和其他同步器的基础框架。它提供了一套标准...
AQS源码解读（番外篇）——四种自旋锁原理详解（Java代码实现SpinLock
2401_84692141的博客
05-10 942
为了这次面试，也收集了很多的面试题！以下是部分面试题截图。
添加@Async注解，导致spring启动失败
liangsheng_g的专栏
08-29 4163
文章目录前言一、异常表现，抛出内容1.1循环依赖的两个class1.2 启动报错二、原因分析2.1 主要原因2.2 循环依赖放入二级缓存处逻辑2.3 initializeBean生成的对象2.4 再次分析原因总结 前言 在这篇文章里，最后总结处，我说了会讲讲循环依赖中，其中一个类添加@Async有可能会导致注入失败而抛异常的情况，今天就分析一下。 一、异常表现，抛出内容 1.1循环依赖的两个class CycleService1 @Service public class CycleService1
Spring的AOP执行顺序
liangsheng_g的专栏
01-26 4087
Spring中的Advisors的执行顺序
@EnableAutoConfiguration的使用和原理
liangsheng_g的专栏
11-08 3890
Springboot @EnableAutoConfiguration原理Springboot是如何加载@EnableAutoConfiguration1. 如何把自己的配置类加入到Spring容器中呢？1.1 spring.factories2. 探究Springboot是如何加载我们的配置类的2.1 注解介绍2.1.1 @SpringbootApplication注解是什么2.1.2 @SpringbootConfiguration注解2.1.3 @EnableAutoConfiguration注解2.
单元测试加上@Transactional就能实现回滚【原理】
liangsheng_g的专栏
12-18 3701
单元测试自动回滚
DependsOn注解失效问题排查
liangsheng_g的专栏
10-08 1952
@DependsOn注解失效分析及解决
spring源码解读：@Async的原理——默认配置
liangsheng_g的专栏
08-22 1819
文章目录前言一、如何使用@Async二、源码解读1.@EnableAsync的作用2. AsyncConfigurationSelector的作用3. adviceMode:PROXY(默认值)3.1 ProxyAsyncConfiguration3.2 AsyncAnnotationBeanPostProcessor3.3 AsyncAnnotationAdvisor3.3.1 buildAdvice3.3.1.1 AnnotationAsyncExecutionInterceptor，异步执行的原理3.
java JUC源码解读 详细
最新发布
02-25
<think>嗯，用户之前让我介绍过Java多线程的基础知识，现在他们想深入了解JUC（java.util.concurrent）的源码。这说明用户可能已经掌握了多线程的基本概念和使用方法，现在想更深入理解底层实现，提升自己的技术水平。 首先，我需要确定用户对JUC的了解程度。他们可能已经用过一些工具类，比如ReentrantLock或CountDownLatch，但现在想了解这些类内部的机制。用户可能是中高级开发者，希望优化代码性能，或者准备面试，需要深入理解并发框架。 接下来，我需要考虑如何组织内容。直接深入源码可能会让用户感到困惑，所以应该先从JUC的整体结构入手，然后分模块解析核心类。比如，原子类、锁、同步器、并发集合、线程池等，每个部分都需要挑选关键点进行讲解。 用户可能需要知道关键设计模式，比如AQS（AbstractQueuedSynchronizer），因为这是JUC的核心。需要详细解释AQS的工作原理，如CLH队列、状态管理等。此外，CAS操作和volatile关键字也是实现无锁并发的基础，需要结合源码说明它们的作用。 另外，用户可能对常见类的实现感兴趣，比如ReentrantLock的公平锁与非公平锁区别，ConcurrentHashMap的分段锁或CAS优化，线程池的任务调度流程等。需要结合代码示例和流程图，帮助用户理解这些复杂机制。 同时，要注意避免过于冗长的代码展示，而是聚焦在关键方法和设计思路上。例如，AQS的acquire和release方法，以及它们如何被ReentrantLock或Semaphore调用。此外，可以比较不同版本的实现变化，比如JDK1.7和1.8中ConcurrentHashMap的改进，让用户了解优化方向。 最后，需要给出学习建议，推荐用户如何逐步深入源码，比如从简单的AtomicInteger开始，再逐步研究AQS和锁的实现。同时，提醒用户注意调试和测试的重要性，通过实际案例加深理解。 总结下来，回答的结构应该是先概述JUC的重要性，再分模块解析核心源码，结合关键设计模式和具体类实现，最后给出学习方法和资源推荐。这样既系统又深入，帮助用户由浅入深地掌握JUC源码。</think>好的！`java.util.concurrent`（JUC）是 Java 并发编程的核心工具包，包含大量高性能、线程安全的工具类和框架。深入源码理解其设计思想，能帮助你掌握高并发编程的精髓。以下从 **核心模块**、**设计模式**、**关键类源码分析** 三个维度进行详细解读。 --- ### **一、JUC 整体架构** JUC 的核心模块包括： 1. **原子类**（Atomic）：基于 CAS 的无锁并发操作（如 `AtomicInteger`）。 2. **锁与同步器**（Locks）：如 `ReentrantLock`、`AQS`（AbstractQueuedSynchronizer）。 3. **并发容器**（Collections）：如 `ConcurrentHashMap`、`CopyOnWriteArrayList`。 4. **线程池**（Executors）：`ThreadPoolExecutor`、`ForkJoinPool`。 5. **同步工具**（Tools）：`CountDownLatch`、`CyclicBarrier`、`Semaphore`。 6. **并发流与 Future**：如 `CompletableFuture`、`ForkJoinTask`。 --- ### **二、核心源码解读** #### **1. AQS（AbstractQueuedSynchronizer）** AQS 是 JUC 锁和同步器的基石（如 `ReentrantLock`、`Semaphore` 均基于它实现）。 ##### **核心设计** - **状态变量（state）**：通过 `volatile int state` 表示资源状态（如锁的持有次数）。 - **CLH 队列**：一个双向链表实现的等待队列，存储竞争资源的线程。 - **模板方法模式**：子类只需实现 `tryAcquire`/`tryRelease`，AQS 负责线程排队和唤醒。 ##### **源码关键方法** ```java // 独占模式获取资源（如 ReentrantLock.lock()） public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); } // 子类需实现 tryAcquire（如判断 state 是否为0） protected boolean tryAcquire(int arg) { throw new UnsupportedOperationException(); } ``` ##### **实现示例：ReentrantLock 的公平锁** ```java // 公平锁的 tryAcquire 实现 protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (!hasQueuedPredecessors() && // 关键：检查队列是否有等待线程 compareAndSetState(0, acquires)) { // CAS 更新状态 setExclusiveOwnerThread(current); return true; } } // 处理重入逻辑（state 增加） else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; setState(nextc); return true; } return false; } ``` --- #### **2. 原子类（AtomicInteger）** 原子类的核心是 **CAS（Compare-And-Swap）** 操作，直接依赖 CPU 指令（如 x86 的 `cmpxchg`）。 ##### **源码关键实现** ```java public class AtomicInteger extends Number implements java.io.Serializable { private volatile int value; // 通过 volatile 保证可见性 public final int getAndIncrement() { return unsafe.getAndAddInt(this, valueOffset, 1); } } // Unsafe 类的 CAS 操作（native 方法） public final class Unsafe { public final native boolean compareAndSwapInt( Object o, long offset, int expected, int x); } ``` ##### **CAS 的 ABA 问题** - **问题**：变量从 A 改为 B 又改回 A，CAS 无法感知中间变化。 - **解决方案**：使用 `AtomicStampedReference` 添加版本号。 --- #### **3. ConcurrentHashMap（JDK 1.8）** JDK 1.8 摒弃分段锁，改用 **CAS + synchronized** 实现更细粒度的锁。 ##### **关键设计** - **Node 数组（table）**：每个桶位（bucket）是一个链表或红黑树。 - **并发控制**： - **CAS 初始化数组**：避免多线程重复初始化。 - **synchronized 锁桶头节点**：仅锁定单个桶，减少竞争。 ##### **putVal 方法核心逻辑** ```java final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw new NullPointerException(); int hash = spread(key.hashCode()); int binCount = 0; for (Node<K,V>[] tab = table;;) { Node<K,V> f; int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); // CAS 初始化数组 else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value))) break; // CAS 插入新节点 } else if ((fh = f.hash) == MOVED) tab = helpTransfer(tab, f); // 协助扩容 else { synchronized (f) { // 锁住桶头节点 // 插入链表或红黑树 } } } } ``` --- #### **4. ThreadPoolExecutor** 线程池的核心是 **任务队列** 和 **线程调度策略**。 ##### **核心参数** - **corePoolSize**：核心线程数（即使空闲也不销毁）。 - **workQueue**：任务队列（如 `LinkedBlockingQueue`）。 - **RejectedExecutionHandler**：拒绝策略（如丢弃、抛异常）。 ##### **execute 方法逻辑** ```java public void execute(Runnable command) { if (command == null) throw new NullPointerException(); int c = ctl.get(); if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) // 创建新线程执行任务 return; c = ctl.get(); } if (isRunning(c) && workQueue.offer(command)) { // 任务入队 // 二次检查线程池状态 } else if (!addWorker(command, false)) // 尝试创建非核心线程 reject(command); // 触发拒绝策略 } ``` --- ### **三、JUC 设计模式与技巧** 1. **CAS 无锁编程** - 通过 `Unsafe` 类直接操作内存，避免锁竞争（如原子类、ConcurrentHashMap）。 - 适用场景：读多写少，竞争不激烈。 2. **模板方法模式** - AQS 将公共逻辑（如线程排队）抽象到基类，子类只需实现特定方法（如 `tryAcquire`）。 3. **写时复制（Copy-On-Write）** - `CopyOnWriteArrayList` 在修改时复制整个数组，保证读操作无锁。 4. **分段锁优化** - JDK 1.7 的 `ConcurrentHashMap` 使用分段锁（Segment），减少锁粒度。 --- ### **四、高频源码面试题** 1. **AQS 的 CLH 队列为什么是双向链表？** - 答：为了支持取消操作（如超时或中断），需要快速定位前驱节点。 2. **ConcurrentHashMap 1.7 和 1.8 的区别？** - 1.7：分段锁 + ReentrantLock； - 1.8：CAS + synchronized + 红黑树。 3. **线程池如何回收空闲线程？** - 答：`ThreadPoolExecutor` 通过 `getTask()` 中的 `poll(keepAliveTime)` 实现超时回收。 --- ### **五、学习建议** 1. **调试源码**：通过 IDE 调试 `ReentrantLock.lock()` 的执行流程。 2. **阅读注释**：JUC 类的源码注释通常包含设计思路和并发规则。 3. **手写简化版**：尝试实现一个简单的 AQS 或线程池。 理解 JUC 源码不仅能提升并发编程能力，还能深入掌握 Java 的高性能设计哲学。建议从 `AtomicInteger` 和 `ReentrantLock` 入手，逐步扩展到复杂类如 `ConcurrentHashMap` 和 `ThreadPoolExecutor`。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值