Skip to content

2.4-3 AQS 原理与 ReentrantLock 源码 ​

所属:02 Java 运行时 / 2.4 并发 分级:A 状态:◐ 初稿 关联:2.4-1、2.4-2、2.4-4、2.4-5、2.4-9、2.4-10、2.4-11

  • 题型:原理 / 源码

  • 一句话结论:AQS 是 JUC 的同步器骨架:一个 volatile int state 加一个 CLH 变体 FIFO 等待队列,子类通过 tryAcquire/tryRelease(共享模式用 tryAcquireShared/tryReleaseShared)定义 state 语义,AQS 负责排队、阻塞、唤醒、中断和 Condition;ReentrantLock 用 state 表示重入次数,非公平锁先 CAS 抢锁,公平锁先检查队列前驱。

  • 分层要点:

    1. 设计定位与模板方法:AbstractQueuedSynchronizer 继承 AbstractOwnableSynchronizer,本身不是锁,而是“同步状态 + 等待队列 + 阻塞/唤醒”的骨架。它把“state 代表什么”留给子类:ReentrantLock 的 state 是重入次数,Semaphore 是许可证数量,CountDownLatch 是倒计数,ReentrantReadWriteLock 把 state 高低 16 位拆成读/写计数,ThreadPoolExecutor.Worker 用 0/1 表示是否持有(构造时 -1 禁止中断)。AQS 提供 acquire/release、acquireShared/releaseShared、acquireInterruptibly、tryAcquireNanos 等模板方法,子类只实现 tryAcquire/tryRelease/tryAcquireShared/tryReleaseShared/isHeldExclusively。
    2. 核心结构与 state:核心字段是 volatile int state、head、tail;Node 有 prev/next/thread/waitStatus/nextWaiter。waitStatus 的取值:0 初始、SIGNAL(-1) 后继需要唤醒、CANCELLED(1) 已取消、CONDITION(-2) 在条件队列、PROPAGATE(-3) 共享释放需要传播。head 是哨兵节点,真正的等待者在 head 之后;队列是 CLH 变体,但原版 CLH 在前驱上自旋,AQS 用 LockSupport.park/unpark 阻塞,避免长时间自旋。state 通过 CAS 修改,配合 volatile 语义和 LockSupport 建立锁的 happens-before;具体含义由子类定义,不能说“AQS 的 state 就是锁计数”。
    3. 独占模式 acquire/release:acquire(arg) 先 tryAcquire,失败才 addWaiter(Node.EXCLUSIVE) 入队,再 acquireQueued。addWaiter 先快速 CAS 抢 tail,失败走 enq 自旋;acquireQueued 在循环里检查前驱是否为 head,是就再试一次 tryAcquire,成功则 setHead 并清理;否则 shouldParkAfterFailedAcquire 把前驱置为 SIGNAL,然后 parkAndCheckInterrupt 阻塞。release(arg) 先 tryRelease,成功且 head 需要唤醒时 unparkSuccessor;它从 tail 往前找未取消的后继,因为并发取消时 next 可能不可靠,prev 更稳定。acquire 对中断是“记录后补中断”,真正可中断要用 acquireInterruptibly。
    4. 公平/非公平与 ReentrantLock:ReentrantLock 内部 Sync extends AQS,分 NonfairSync 和 FairSync。非公平锁 lock() 先 CAS state 0→1,成功直接持有,失败再 acquire(1);tryAcquire 调 nonfairTryAcquire,state 为 0 就 CAS,当前线程已是 owner 就 state += acquires 实现重入。公平锁的 tryAcquire 多一个 hasQueuedPredecessors():队列里有人排队就不抢,保证先来后到。unlock() 调 release(1),tryRelease 减 state,减到 0 才清 owner;减多了或非 owner 解锁会抛 IllegalMonitorStateException。默认非公平,吞吐更高但可能饥饿;公平锁更可预测但切换更多。
    5. 共享模式、Condition 与生产:共享模式用 tryAcquireShared,返回值语义是“负数失败、0 成功但不传播、正数成功且允许传播”;doAcquireShared 成功后 setHeadAndPropagate,releaseShared 走 doReleaseShared。Semaphore 的 state 是许可证,CountDownLatch 的 state 是剩余计数,都是共享模式。Condition 是 AQS 的内部类:await 把当前线程放入条件队列,fullyRelease 释放全部重入次数,然后 park;signal 把节点从条件队列转移到同步队列并 unpark,被唤醒后还要重新 acquireQueued 抢锁。await 必须在锁内调用,并且要在 while 循环里检查条件。虚拟线程下 ReentrantLock 的 park 可以卸载虚拟线程,通常比 synchronized 更友好。
  • 图/流程:

text
lock() / acquire(1)
  │
  ├─ tryAcquire 成功 ──► 临界区
  │
  └─ 失败
       ▼
   addWaiter(Node.EXCLUSIVE)  ──CAS tail──►  入队
       ▼
   acquireQueued
       ├─ 前驱是 head 且 tryAcquire 成功 ──► setHead,返回
       └─ shouldParkAfterFailedAcquire
              ├─ 前驱 SIGNAL ──► park
              └─ 否则 CAS 前驱为 SIGNAL,再试
  unlock() / release(1)
       ├─ tryRelease 成功
       └─ unparkSuccessor:从 tail 向前找未取消节点
text
Condition.await()
  ├─ addConditionWaiter()        // 进条件队列
  ├─ fullyRelease()              // 完全释放锁
  ├─ park
  └─ 被 signal 后转回同步队列 → acquireQueued 重新抢锁

Condition.signal()
  ├─ 必须持有锁
  ├─ 取条件队列第一个节点
  └─ transferForSignal → 入同步队列 → unpark
  • 版本/源码锚点:

    • JDK 8+:AbstractQueuedSynchronizer、ReentrantLock、ConditionObject 源码结构基本稳定。
    • state、head、tail、Node 的 waitStatus 是面试最常问的字段。
    • JDK 21:虚拟线程下 LockSupport.park 可卸载虚拟线程;ReentrantLock 通常优于 synchronized 的 pinning 行为。
    • 相关类:Semaphore、CountDownLatch、ReentrantReadWriteLock、ThreadPoolExecutor.Worker 都基于 AQS。
  • AQS 子类映射表:

同步器模式state 含义关键实现
ReentrantLock独占重入次数tryAcquire / tryRelease
Semaphore共享剩余许可证tryAcquireShared / tryReleaseShared
CountDownLatch共享剩余计数state 为 0 才放行
ReentrantReadWriteLock共享 + 独占高 16 位读计数、低 16 位写计数读锁 shared、写锁 exclusive
ThreadPoolExecutor.Worker独占0/1(启动前 -1)非重入,配合线程中断
  • Node.waitStatus 表:
值名称含义
0初始新节点默认状态
-1SIGNAL后继需要被唤醒
1CANCELLED等待超时/中断/取消
-2CONDITION在 Condition 条件队列
-3PROPAGATE共享模式下释放需要传播
  • 公平 / 非公平对比:
维度非公平锁公平锁
抢锁新线程可直接 CAS 插队先看 hasQueuedPredecessors
吞吐通常更高通常更低
饥饿极端情况可能饥饿先来后到,更可预测
默认ReentrantLock 默认需显式 new ReentrantLock(true)
  • 核心源码片段:
java
// AQS 独占获取模板
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

// ReentrantLock 非公平尝试
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (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;
}
  • 追问链:

    1. AQS 是什么?为什么说是“骨架”? → 它只提供 state、FIFO 队列、park/unpark 和模板方法,具体“什么算获取成功”由子类实现;所以它能同时支撑锁、信号量、倒计数、读写锁。
    2. AQS 的 state 是锁计数吗? → 不是通用含义;ReentrantLock 里是重入次数,Semaphore 里是许可证,CountDownLatch 里是剩余计数,RRWL 里拆成读写计数。面试要先说“由子类定义”。
    3. acquire 的完整流程? → tryAcquire 失败 → addWaiter 入队 → acquireQueued 循环 → 前驱是 head 就再试 → 失败则把前驱置 SIGNAL 并 park;成功后 setHead,必要时 selfInterrupt。
    4. 为什么 head 是虚拟节点? → 统一队列操作,避免空指针和边界判断;head 不代表等待线程,真正的后继从 head.next 开始,唤醒时也更容易处理。
    5. unparkSuccessor 为什么从 tail 往前找? → 节点取消时 next 链可能断/不一致,prev 更可靠;从 tail 反向找到最近的未取消节点再 unpark。
    6. waitStatus 有哪些状态? → 0 初始、SIGNAL 后继需唤醒、CANCELLED 已取消、CONDITION 在条件队列、PROPAGATE 共享传播。
    7. 公平锁和非公平锁差在哪? → 公平锁的 tryAcquire 先 hasQueuedPredecessors,有人排队就不插队;非公平锁先 CAS,吞吐高但可能饥饿。
    8. ReentrantLock 的可重入怎么实现? → state 记录重入次数,exclusiveOwnerThread 记录持有者;同一线程再次 tryAcquire 就 state 加一,解锁减一,减到 0 才真正释放。
    9. acquire 和 lockInterruptibly 有什么区别? → acquire 在等待中收到中断只记录,抢到锁后再 selfInterrupt;lockInterruptibly 会抛 InterruptedException,适合可取消任务。
    10. Condition 的 await/signal 怎么工作? → await 进条件队列、完全释放锁、park;signal 把节点转到同步队列并 unpark;被唤醒后还要重新抢锁,所以条件判断要放在 while 循环。
    11. AQS 共享模式的返回值怎么理解? → 负数失败;0 成功但不向后传播;正数成功且允许继续唤醒后继。Semaphore/CountDownLatch 都依赖这个语义。
    12. ReentrantReadWriteLock 怎么用一个 state 表示读写? → 高 16 位读计数,低 16 位写计数;读锁 shared,写锁 exclusive;支持写锁降级为读锁,不支持读锁升级。
    13. AQS 和 synchronized 怎么选? → 简单互斥用 synchronized;需要公平、tryLock、超时、可中断、多个 Condition 时用 ReentrantLock/AQS;虚拟线程场景 ReentrantLock 通常更友好。
    14. ThreadPoolExecutor.Worker 为什么继承 AQS? → 它需要一个非重入的独占锁来保护 Worker 的中断状态和任务执行;tryAcquire 只允许 0→1,setState(-1) 在启动前禁止中断,lock/unlock 配合 shutdownNow。
    15. AQS 有哪些常见坑? → lock/unlock 不配对、持锁做 RPC/IO、await 不在循环、signal 早于 await 丢失、公平锁性能下降、无参 tryLock 在公平锁下仍可能插队。
  • 生产案例/取舍(示例,替换成你的项目):

    • 下游接口超时导致线程池堆积,用 Semaphore 限制并发数,state 就是许可证;非公平模式吞吐高,但要注意慢调用占满许可证,配合超时和隔离。
    • 多资源加锁用 tryLock(timeout) 避免无限等待,失败后释放已持有的锁并回滚;lockInterruptibly 用于可取消的批处理任务。
    • 用 ReentrantLock + Condition 实现有界队列,notFull.await()/notEmpty.signal() 必须在 while 循环里;相比 wait/notify,Condition 可以分出多个等待队列。
    • 公平锁上线后吞吐下降、上下文切换增多;非公平锁在极端竞争下出现个别线程饥饿。取舍是吞吐 vs 可预测性,要用压测和监控决定。
    • 持锁调用 RPC/DB 导致 AQS 队列变长、TP99 飙升;把 IO 移出临界区,或缩小锁粒度/分段锁。
    • 虚拟线程服务里用 ReentrantLock 替代 synchronized,避免载体线程被 pin;但锁竞争本身仍在,别把锁当万能药。
  • 易错点:

    • 把 AQS 的 state 统一定义为“锁计数”。
    • 认为 AQS 本身就是锁,或认为它可以直接实例化。
    • 认为 head 是第一个等待线程(实际是哨兵)。
    • 认为 unparkSuccessor 从 head 往后找;实际从 tail 往前找更可靠。
    • 认为 acquire 可中断;它只是记录中断,lockInterruptibly 才抛异常。
    • 认为 tryLock() 在公平锁下也一定公平;无参 tryLock() 走非公平尝试。
    • 认为 Condition.await 不需要持有锁,或 signal 后等待线程立刻执行。
    • 把 await 写在 if 里,忽略虚假唤醒和条件变化。
    • 认为 ReentrantReadWriteLock 支持读锁升级为写锁。
    • 持锁做远程调用/大文件 IO,导致队列堆积和死锁风险。
  • 30 秒口述稿:

AQS 是 JUC 的同步器骨架:一个 volatile state 加一个 CLH 变体 FIFO 队列,子类实现 tryAcquire/tryRelease 定义 state 语义,AQS 负责入队、park/unpark、中断和 Condition。ReentrantLock 用 state 记重入次数:非公平锁先 CAS 抢,公平锁先 hasQueuedPredecessors;抢不到就入队,前驱是 head 就再试,否则置 SIGNAL 后 park;release 从 tail 往前找未取消的后继唤醒。共享模式支撑 Semaphore/CountDownLatch;Condition 的 await 完全释放锁进条件队列,signal 转回同步队列再重新抢锁。AQS 把状态语义和排队阻塞分离,这是它支撑整个 JUC 的原因。

  • 3 分钟展开顺序:结论(state + FIFO + 模板方法)→ state 在各类中的含义 → Node/waitStatus/head 哨兵 → acquire/release 源码 → 公平/非公平与 ReentrantLock 重入 → 共享模式与 Semaphore/CountDownLatch → Condition await/signal → Worker/虚拟线程等生产取舍 → 常见坑。