知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 51 - AQS 与 ReentrantLock 原理 > 导读:本文从"synchronized 已经够用,为什么还要 ReentrantLock"这个疑问出发,把 AQS 的 state + 等待队列模型、独占锁获取与释放的完整链路、公平与非公平的实现差异、可重入与 Condition 的落地方式一次讲透,最后给出生产用法与踩坑。适合想搞懂 JUC 锁底层、以及正在准备后端面试的同学。 ## 一、先建立全局认知 ### Q:已经有 synchronized 了,为什么还需要 ReentrantLock? A:结论先行——两者的差异不在"性能",而在"能力"。 `synchronized` 是**语言级的锁**:写法简单、由 JVM 保证异常时自动释放,但功能是固定的。`ReentrantLock` 是**API 级的锁**,补上了 `synchronized` 做不到的四件事: 1. **可中断地获取锁**:`lockInterruptibly()`,等待锁的过程中能被中断打断,不会一直挂着。 2. **可超时地获取锁**:`tryLock(timeout)`,抢不到就返回 `false`,把"无限等待"变成"可控失败"。 3. **可声明公平性**:构造参数 `fair`,可选择严格 FIFO,避免饥饿。 4. **可以绑定多个条件队列**:一个锁上能 `newCondition()` 出多个 Condition,实现精确唤醒。 代价也很明确:**必须手写 `unlock()` 且必须放在 `finally` 里**,泄漏一次锁就是全站阻塞;而 `synchronized` 由 JVM 兜底,不会漏。 需要补充的是,JDK 6 之后 `synchronized` 引入了偏向锁、轻量级锁等优化,两者的吞吐差距已经大幅缩小(顺带一提,偏向锁在 JDK 15 已被默认禁用并标记为废弃,即 JEP 374)。所以"要不要用 ReentrantLock"的判断依据应该是**功能需求**,而不是"它更快"。 ### Q:AQS 是什么?它到底解决了什么问题? A:AQS(`AbstractQueuedSynchronizer`,抽象队列同步器)是 JUC 中锁与同步器的**骨架**。它把"线程怎样排队等待、怎样被唤醒、怎样保证只有一个线程能通过"这套高度重复的逻辑下沉到框架里,只把"**什么叫做获取成功**"留给子类实现。 它由三个部分组成: - **一个 `volatile int state`**:同步状态。`0` 表示空闲,大于 `0` 表示已被占用;在独占模式下它同时被复用为**重入次数**。 - **一条 FIFO 双向等待队列**:AQS 文档称其为 CLH 队列的变体。获取失败的线程会被包装成 `Node` 入队并挂起。 - **一组模板方法**:`acquire` / `release` 是模板(最终方法,定义了骨架流程),`tryAcquire` / `tryRelease`(独占)与 `tryAcquireShared` / `tryReleaseShared`(共享)是留给子类的钩子。子类只需要回答"这次算不算成功"。 一句话概括:**AQS = 一个 state + 一条等待队列 + 一套模板方法**。 `ReentrantLock`、`ReentrantReadWriteLock`、`Semaphore`、`CountDownLatch`,以及线程池里 `ThreadPoolExecutor.Worker` 的加锁,都是基于 AQS 实现的。理解了 AQS,这一批工具就都能顺着同一套模型推下来。 ## 二、理解核心机制 ### Q:state 与等待队列是怎么协作的? A:一个线程来抢锁,本质就是"**用 CAS 把 state 从 0 改成 1**",成败决定它接下来走哪条路: - CAS 成功:抢到锁,同时把 `exclusiveOwnerThread` 记录为自己; - CAS 失败:说明锁已被别人持有(或自己重入),把当前线程包装成 `Node` 挂到队列尾部,然后 `park` 阻塞; - 持有线程释放时:把 `state` 减到 `0`,再唤醒队列里的后继节点。  *图:AQS 独占模式的协作模型——线程用 CAS 抢占 state;失败的线程进入双向同步队列并 park,持锁线程释放后再 unpark 唤醒后继。* ### Q:独占式获取锁 `acquire(1)` 的完整链路是什么? A:AQS 给出的模板方法是(下述源码取自 JDK 8): ```java public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); } ``` 这四行可以拆成四步: 1. **`tryAcquire(arg)`**:调用子类钩子,先做一次"快路径"尝试。成功就直接返回,完全不碰队列。 2. **`addWaiter(Node.EXCLUSIVE)`**:快路径失败,把当前线程包装成独占模式的 Node,先尝试 CAS 一次挂到队尾;失败再进 `enq` 自旋入队(保证并发入队时链表不丢节点)。 3. **`acquireQueued(node, arg)`**:在队列里自旋判断。如果**前驱是 head**(说明轮到自己了),就再调一次 `tryAcquire`;如果还没轮到,就用 `shouldParkAfterFailedAcquire` 确认"可以安全挂起",然后 `parkAndCheckInterrupt` 真正阻塞。 4. **被唤醒后**:从 `park` 处回来,重新走上面的循环;一旦抢到锁,就把自己设为新的 `head`,完成出队。 这里有三个容易被忽略的设计点: - **第一次 `tryAcquire` 是无锁的**:绝大多数情况下锁是空闲的,这一步直接拿到锁,避免了入队、park 这些昂贵的操作。它是 AQS 性能设计的核心,思路和单例 DCL 的"第一次检查不加锁"如出一辙。 - **`park` 是不可逆的**:被 `unpark` 唤醒后不会自动回到某一行代码,而是继续循环重新竞争,所以线程可能"醒了但没抢到锁",然后再次 park。 - **返回值 `true` 表示等待期间被中断过**:`park` 本身不响应中断,是靠检测到中断标记后返回的,因此外层要补一次 `selfInterrupt()`,把这个中断标记重新打回去,不吞掉调用方的中断语义。 ### Q:公平锁和非公平锁差在哪一行代码?为什么非公平吞吐更高? A:非公平锁的 `lock()` 里藏着一个"插队"动作——它先直接抢一次,抢不到才进入队列逻辑: ```java // ReentrantLock.NonfairSync(JDK 8) final void lock() { if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); } ``` 公平锁则不插队,`lock()` 直接调 `acquire(1)`,真正的差别体现在 `tryAcquire` 里——多了一次 `hasQueuedPredecessors()` 判断: ```java // ReentrantLock.FairSync(JDK 8) protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (!hasQueuedPredecessors() && // ← 关键的一行 compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { // 重入分支 int nextc = c + acquires; if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; } ``` `hasQueuedPredecessors()` 的含义是"**队列里有没有排在我前面的线程**":只要有人在排队,这次尝试就直接失败,老老实实去队尾——这就是公平的准确定义。 **为什么 `new ReentrantLock()` 默认是非公平?** 因为非公平允许"刚到的线程立刻拿到锁",省掉了一段昂贵的开销:唤醒一个排队线程,需要把它从内核态恢复、再重新参与竞争,这期间锁一直是空闲的;让新来的线程直接拿走,CPU 利用率更高、吞吐更好。代价是排队线程可能被反复插队,极端情况下**饥饿**。 这里的取舍是:默认选择吞吐,需要确定性时(比如严格按顺序、或对延迟抖动敏感)再通过 `new ReentrantLock(true)` 用吞吐换公平。 ### Q:可重入是怎么实现的? A:靠两件事配合——**持有者判断**加上 **state 计数**。 - **加锁时的重入**:就是上面 `tryAcquire` 里的 `else if` 分支。如果 `current == getExclusiveOwnerThread()`,说明是持有锁的同一个线程又来了,于是 `state + acquires`(重新计数),直接返回成功。 - **解锁时的递减**:`release` 会调用 `tryRelease`,每次把 `state` 减掉一次,**只有减到 0 才算真正释放**: ```java // ReentrantLock.Sync(JDK 8) protected final boolean tryRelease(int releases) { int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; if (c == 0) { // 只有减到 0 才算释放 free = true; setExclusiveOwnerThread(null); } setState(c); return free; // 返回 true 才会去唤醒后继节点 } ``` 由此推出两条硬性约束:**加锁几次就必须解锁几次**,否则 `state` 不归零,锁永远不会释放;以及 `unlock()` 只能由持锁线程调用,否则直接抛 `IllegalMonitorStateException`。 至于"为什么要可重入":如果没有它,方法 A 加了锁、A 内部又调用同样加锁的方法 B 时,就会自己把自己锁死。 ### Q:Condition 是怎么实现的?它和同步队列是什么关系? A:Condition 内部维护**另一条队列**——条件队列,与 AQS 的同步队列是两条不同的队列: - **`await()`**:把当前线程包装成 Node 加入条件队列,**完全释放锁**(把 `state` 保存后清零),然后 park 挂起; - **`signal()`**:把条件队列的头节点**转移到同步队列的尾部**,之后它还要在同步队列里正常竞争锁,抢到锁才能从 `await()` 返回。 两个必须记住的细节: 1. **`await()` 前必须持有锁**,否则抛 `IllegalMonitorStateException`——这一点和 `Object.wait()` 的要求一致。 2. **被唤醒 ≠ 立刻继续执行**:`signal()` 只是搬运节点,线程醒来后还要重新 acquire 锁,所以从 `await()` 返回到真正执行后续代码,中间隔着一次完整的抢锁。 一个锁可以有**多个 Condition**,这是它比 `synchronized + wait/notify` 更强的地方,也是能写出高效生产者消费者的原因:用两个条件分别表示"队列不满"和"队列不空",生产者只在"不满"上等待、消费者只在"不空"上等待,避免了 `notifyAll()` 把无关线程全部唤醒的无用功。 ## 三、放进真实场景 ### Q:真实业务里什么时候必须用 ReentrantLock? A:当需求落在前面那四项能力上时,`synchronized` 就无能为力了。最常见的三种: 1. **抢不到要能放弃或超时**:`tryLock(timeout)`,把"接口线程无限挂起"改成"快速失败 + 降级"。 2. **要能被中断**:`lockInterruptibly()`,配合任务取消、优雅停机。 3. **要多个等待条件**:一个锁配多组 Condition,阻塞队列、连接池都是这个套路("有空位 / 有元素"、"有空闲连接 / 有等待者")。 生产里 `tryLock` 的标准写法如下,重点是**只有拿到锁才允许解锁**: ```java private final ReentrantLock lock = new ReentrantLock(); public String query(String key) { try { if (lock.tryLock(200, TimeUnit.MILLISECONDS)) { try { // 临界区:只有真正拿到锁才执行 return loadFromDb(key); } finally { lock.unlock(); // 成对释放 } } // 抢锁超时:走降级,而不是无脑等待 return loadFromCache(key); } catch (InterruptedException e) { Thread.currentThread().interrupt(); // 恢复中断标记,交给上层处理 return loadFromCache(key); } } ``` 两个容易被忽略的点:一是 `tryLock` 返回 `false` 时**绝对不能调用 `unlock()`**,因为此时根本没持锁,会直接抛 `IllegalMonitorStateException`;二是 `InterruptedException` 要恢复中断标记(`Thread.currentThread().interrupt()`)再返回,否则上层感知不到中断,优雅停机可能被卡住。 ### Q:线上使用 ReentrantLock 最容易踩的坑有哪些? A:三个高频问题,本质都出在"锁的生命周期没有闭环": 1. **`unlock()` 没放在 `finally`**:临界区抛异常或提前 `return`,锁就永远不会释放,后续线程全部阻塞,最终表现为"接口全量超时、线程栈全是 WAITING"。正确姿势是 `lock()` 紧跟 `try`,`unlock()` 放 `finally`——这是和 `synchronized` 最大的使用差别。 2. **锁对象不共享**:锁加在了局部变量、或每次都 `new ReentrantLock()`,等于没有加锁。这和 `synchronized` 锁错对象是同一类错误,而且更隐蔽——因为代码看起来"确实加了锁"。 3. **重入次数没归零**:重入 3 次只 `unlock()` 了 2 次,`state` 停在 1,锁不会释放。这类问题排查时可以先用 `getHoldCount()` 看当前线程持有次数。 排查线上锁相关问题时,`ReentrantLock` 比 `synchronized` 更好用:`getQueueLength()`、`getQueuedThreads()`、`isLocked()`、`isFair()` 这些方法能把"谁在等、等多久"直接暴露出来,可以接到监控里做告警;而 `synchronized` 只能靠 jstack 看线程状态。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:建议按"模型 → 链路 → 取舍"三段来答: 1. **先给模型**:AQS = 一个 volatile 的 state + 一条 CLH 变体的双向等待队列 + 一套模板方法;`ReentrantLock` 的 `Sync` 就是它的子类,只实现 `tryAcquire` / `tryRelease`。 2. **再讲链路**:`acquire(1)` 先走无锁的 `tryAcquire` 快路径,失败后 `addWaiter` 入队、`acquireQueued` 自旋并 park;释放时 `tryRelease` 把 state 减到 0 再 `unpark` 后继;公平与非公平只差 `hasQueuedPredecessors()` 一行。 3. **最后讲取舍**:默认非公平是为了吞吐(避免唤醒空窗),公平用吞吐换确定性;可重入靠 state 计数;Condition 用的是独立的条件队列,signal 只是把节点搬到同步队列;`synchronized` 与 `ReentrantLock` 的选型看功能需求(可中断、可超时、可公平、多条件),而不是性能。 ### Q:如果面试官追问"你到底用哪个"? A:多数场景优先 `synchronized`——写法简单、不会漏释放、JVM 还有锁优化。只有当需求明确落在"可中断、可超时、可公平、多条件队列"这四点上时,才换成 `ReentrantLock`,并接受"必须手动 unlock"这个代价。这个回答体现的是**先看需求、再谈取舍**,而不是背源码。 --- ## 自测 1. AQS 的 `state` 在独占模式下承担了哪两个职责?为什么可重入要靠它计数? 2. `acquire(1)` 的四步分别是什么?为什么"第一次 `tryAcquire` 不加锁"对性能很关键? 3. 非公平锁可能导致饥饿,为什么它仍然是默认选择?公平锁多付出的代价具体是什么? 4. `tryLock(timeout)` 返回 `false` 时能不能调用 `unlock()`?为什么 `await()` 被 `signal()` 唤醒后不能立刻继续执行?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入