Pinxian Li1. 项目概述
"从入门到入魂：Lock体系与AQS队列同步器源码级深度剖析"这个标题直指Java并发编程的核心痛点——如何真正理解并掌握锁机制的底层实现。作为一名在分布式系统领域摸爬滚打多年的老兵，我见过太多开发者停留在synchronized关键字和ReentrantLock基础API的使用层面，当遇到死锁、性能瓶颈等复杂场景时往往束手无策。本文将带你深入Java并发包的"心脏部位"，通过逐行分析AbstractQueuedSynchronizer（AQS）的源码实现，揭示Lock体系背后的设计哲学。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 核心需求解析
2.1 为什么需要深入理解AQS？
在Java并发编程中，锁是协调多线程访问共享资源的基石工具。但仅仅会使用synchronized或Lock接口的简单API，就像只会开自动挡汽车的司机——当车辆出现故障时完全无从下手。AQS作为Java并发包中Lock、CountDownLatch、Semaphore等同步器的共同基类，其重要性相当于并发世界的"操作系统内核"。
实际开发中遇到的典型问题包括：
- 锁竞争导致的性能骤降
- 死锁问题难以定位
- 自定义同步器无从下手
- 线程状态分析困难
2.2 AQS的核心价值定位
AQS通过模板方法模式，提供了两种同步方式：
- 独占模式：同一时刻只允许一个线程获取资源（如ReentrantLock）
- 共享模式：多个线程可以同时获取资源（如Semaphore）
其核心数据结构是一个FIFO的CLH队列（Craig, Landin, and Hagersten lock queue的变种），通过CAS操作实现无锁化的线程排队管理。这种设计使得基于AQS实现的同步器既保证了线程安全，又获得了极高的性能。
3. AQS架构深度剖析
3.1 核心字段与状态管理
java复制// 同步状态，子类根据不同模式使用
private volatile int state;
// CLH队列头尾节点
private transient volatile Node head;
private transient volatile Node tail;
状态字段state是AQS的灵魂所在：
- 在ReentrantLock中表示重入次数
- 在Semaphore中表示剩余许可数
- 在CountDownLatch中表示剩余计数
状态变更通过CAS保证原子性：
java复制protected final boolean compareAndSetState(int expect, int update) {
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
3.2 节点类Node的精细设计
java复制static final class Node {
// 共享模式标记
static final Node SHARED = new Node();
// 独占模式标记
static final Node EXCLUSIVE = null;
// 线程等待状态
volatile int waitStatus;
// 前驱/后继节点
volatile Node prev;
volatile Node next;
// 关联线程
volatile Thread thread;
// 指向下一个等待节点
Node nextWaiter;
}
节点状态waitStatus的几种关键值：
CANCELLED(1)：线程已取消等待SIGNAL(-1)：后继节点需要唤醒CONDITION(-2)：节点在条件队列中PROPAGATE(-3)：共享模式下传播唤醒
3.3 独占模式获取流程详解
以ReentrantLock的非公平锁实现为例：
java复制final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
关键步骤解析：
- 先尝试直接获取锁（非公平性的体现）
- 失败后调用
tryAcquire（由子类实现） - 将线程包装为Node加入队列尾部
- 进入自旋等待状态
- 被唤醒后再次尝试获取锁
注意：非公平锁虽然可能造成线程饥饿，但减少了线程切换开销，在大多数高并发场景下性能更好
4. 条件变量实现原理
4.1 ConditionObject内部机制
java复制public class ConditionObject implements Condition {
private transient Node firstWaiter;
private transient Node lastWaiter;
public final void await() throws InterruptedException {
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
// ...
}
}
条件变量的本质是维护了一个独立的条件队列：
await()时将节点从同步队列转移到条件队列signal()时将节点从条件队列移回同步队列- 每个ConditionObject维护自己的等待队列
4.2 与synchronized的wait/notify对比
| 特性 | AQS Condition | synchronized |
|---|---|---|
| 多条件支持 | 一个锁可多个条件 | 一个监视器一个条件 |
| 等待前检查 | 支持自定义检查逻辑 | 只能在wait后检查 |
| 中断响应 | 可选择不响应中断 | 总是响应中断 |
| 公平性 | 可配置公平策略 | 完全非公平 |
5. 共享模式实现差异
5.1 与独占模式的关键区别
java复制public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
private void doAcquireShared(int arg) {
final Node node = addWaiter(Node.SHARED);
// ...
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(pred, ws, 0))
continue;
unparkSuccessor(node);
}
// ...
}
共享模式的特点：
tryAcquireShared返回剩余资源数而非boolean- 成功获取后会传播唤醒后续共享节点
- 节点类型为SHARED而非EXCLUSIVE
5.2 Semaphore源码示例
java复制protected int tryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
6. 性能优化关键点
6.1 自旋与阻塞的平衡
AQS在park线程前会进行有限次自旋尝试（尤其是头节点的后继节点），这个优化基于两个观察：
- 持有锁的线程通常很快释放
- 线程挂起/恢复的成本远高于短暂自旋
典型实现见AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire：
java复制private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
return true;
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
6.2 取消节点的处理优化
当线程被中断或超时，需要将节点状态设为CANCELLED。AQS在处理时会：
- 跳过已取消的节点
- 将前驱节点的next指向未取消的后继
- 避免不必要的唤醒操作
7. 实战中的避坑指南
7.1 常见问题排查表
| 现象 | 可能原因 | 解决方案 |
|---|---|---|
| CPU飙升 | 自旋过度或死循环 | 检查锁粒度，增加yield/sleep |
| 吞吐量下降 | 锁竞争激烈 | 改用读写锁或减小临界区 |
| 死锁 | 锁获取顺序不一致 | 统一锁顺序或使用tryLock |
| 线程饥饿 | 非公平锁长期被抢占 | 切换公平锁或优化任务分配 |
| 虚假唤醒 | 条件检查不完整 | 使用while循环而非if检查条件 |
7.2 自定义同步器最佳实践
实现一个简单的门闩同步器示例：
java复制class SimpleLatch {
private static class Sync extends AbstractQueuedSynchronizer {
protected int tryAcquireShared(int acquires) {
return (getState() == 1) ? 1 : -1;
}
protected boolean tryReleaseShared(int releases) {
setState(1);
return true;
}
}
private final Sync sync = new Sync();
public void await() {
sync.acquireShared(1);
}
public void signal() {
sync.releaseShared(1);
}
}
关键实现要点：
- 明确同步语义（共享/独占）
- 正确维护state状态
- 合理处理中断
- 考虑公平性需求
8. 现代并发编程的发展
虽然AQS仍然是Java并发包的基石，但近年来也出现了一些新的并发控制方式：
- StampedLock：乐观读锁实现
- LongAdder：高并发计数优化
- CompletableFuture：异步编程模型
- VarHandle：精细化内存访问控制
但理解AQS的价值在于：
- 掌握最基础的同步原语
- 培养并发问题分析能力
- 为理解更高级并发工具打下基础
在笔者参与的一个高频交易系统中，我们基于AQS实现了自定义的批量锁机制，相比原生ReentrantLock获得了30%以上的吞吐量提升。这种深度优化正是建立在透彻理解AQS的基础上。