李傲文1. AQS（AbstractQueuedSynchronizer）核心原理探索
在Java并发编程领域，AQS（AbstractQueuedSynchronizer）是一个绕不开的核心组件。作为JUC（java.util.concurrent）包中众多同步器的基础框架，AQS支撑了ReentrantLock、CountDownLatch、Semaphore等常用并发工具的实现。理解AQS的工作原理，不仅能够帮助我们更好地使用这些同步工具，还能在需要自定义同步器时提供强大的底层支持。
我第一次深入接触AQS是在优化一个高并发订单系统时。当时系统在高峰期频繁出现线程阻塞和锁竞争问题，通过分析发现是锁使用不当导致的。在尝试各种优化方案的过程中，我意识到必须深入理解AQS的底层机制，才能真正解决这类并发问题。本文将分享我对AQS核心原理的理解和实践经验，希望能帮助你在并发编程的道路上少走弯路。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. AQS整体架构与设计思想
2.1 AQS的基本结构
AQS的核心是一个FIFO的等待队列（CLH队列变种）和一个表示同步状态的整型变量state。这个看似简单的设计却蕴含着精妙的并发控制思想：
java复制// AQS中的关键字段
private volatile int state; // 同步状态
private transient volatile Node head; // 队列头节点
private transient volatile Node tail; // 队列尾节点
state字段的含义由子类定义，比如在ReentrantLock中表示重入次数，在Semaphore中表示可用许可数。等待队列中的每个节点代表一个等待获取资源的线程，节点间通过prev和next指针连接形成双向链表。
2.2 独占与共享模式
AQS支持两种同步模式：
- 独占模式（Exclusive）：同一时刻只有一个线程能获取资源（如ReentrantLock）
- 共享模式（Share）：多个线程可以同时获取资源（如Semaphore）
这两种模式通过不同的方法实现：
java复制// 独占模式核心方法
protected boolean tryAcquire(int arg)
protected boolean tryRelease(int arg)
// 共享模式核心方法
protected int tryAcquireShared(int arg)
protected boolean tryReleaseShared(int arg)
提示：AQS采用了模板方法设计模式，将获取/释放资源的通用逻辑封装在acquire/release等方法中，而将具体的资源获取/释放策略留给子类实现。
3. AQS核心实现原理深度解析
3.1 同步状态的管理
state字段是AQS实现同步控制的核心，所有状态变更都通过CAS操作保证原子性：
java复制// 状态操作方法
protected final int getState() {
return state;
}
protected final void setState(int newState) {
state = newState;
}
protected final boolean compareAndSetState(int expect, int update) {
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
在实际使用中，state的语义由子类定义。例如在ReentrantLock中：
- state=0：锁未被任何线程持有
- state=1：锁被某个线程持有
- state>1：锁被同一个线程重入多次
3.2 等待队列的实现
AQS的等待队列是一个CLH锁队列的变种，采用双向链表实现。每个节点包含以下关键字段：
java复制static final class Node {
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 获取资源的完整流程
以独占模式获取资源为例，核心流程如下：
- 调用tryAcquire尝试获取资源
- 获取失败时，将当前线程包装成Node加入队列尾部
- 不断尝试获取资源或挂起线程
- 被唤醒后检查是否能够获取资源
关键代码实现：
java复制public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
注意：acquireQueued方法中采用"自旋+CAS"的方式确保节点正确入队，这是保证并发安全的关键。
4. AQS在实际开发中的应用
4.1 自定义同步器示例
下面我们实现一个简单的二元闭锁（类似CountDownLatch(1)）：
java复制class OneShotLatch {
private static class Sync extends AbstractQueuedSynchronizer {
protected int tryAcquireShared(int ignored) {
return (getState() == 1) ? 1 : -1;
}
protected boolean tryReleaseShared(int ignored) {
setState(1);
return true;
}
}
private final Sync sync = new Sync();
public void signal() {
sync.releaseShared(1);
}
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
}
这个实现展示了AQS的强大之处 - 只需实现少量方法就能构建一个线程安全的同步器。
4.2 性能优化实践
在使用AQS时，有几个关键性能优化点：
- 减少CAS操作：在tryAcquire/tryRelease中尽量减少CAS操作次数
- 避免不必要的阻塞：先快速尝试获取资源，失败后再进入队列
- 合理设置超时：使用tryAcquireNanos避免无限期等待
- 注意虚假唤醒：条件等待时使用while循环检查条件
5. AQS常见问题与排查技巧
5.1 死锁问题排查
当使用AQS-based锁时，死锁是常见问题。排查步骤：
- 使用jstack获取线程dump
- 查找BLOCKED状态的线程
- 分析锁持有和等待关系
- 检查是否存在循环等待
5.2 性能瓶颈分析
高并发场景下AQS可能成为瓶颈，可通过以下指标监控：
- 队列长度（可通过反射获取）
- 平均等待时间
- CAS操作成功率
- 上下文切换次数
优化建议：
- 考虑减小锁粒度
- 尝试使用读写锁
- 评估是否可以用乐观锁替代
5.3 常见错误用法
- 错误实现tryAcquire：忘记处理重入情况
java复制// 错误实现 - 不支持重入
protected boolean tryAcquire(int arg) {
if (getState() == 0) {
compareAndSetState(0, 1);
return true;
}
return false;
}
// 正确实现 - 支持重入
protected boolean tryAcquire(int arg) {
Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(current);
return true;
}
} else if (current == getExclusiveOwnerThread()) {
setState(c + 1);
return true;
}
return false;
}
- 忘记释放锁：确保在finally块中释放
- 错误使用共享模式：未正确处理tryAcquireShared的返回值
6. AQS高级特性与实现细节
6.1 条件变量的实现
AQS通过ConditionObject内部类实现条件变量功能，其核心是一个独立的条件队列：
java复制public class ConditionObject implements Condition {
private transient Node firstWaiter; // 条件队列头
private transient Node lastWaiter; // 条件队列尾
public final void await() throws InterruptedException {
// 实现细节...
}
public final void signal() {
// 实现细节...
}
}
条件队列与同步队列的关系：
- await()将节点从同步队列转移到条件队列
- signal()将节点从条件队列移回同步队列
6.2 中断处理机制
AQS对中断的处理非常精细：
- 可中断的获取方法（acquireInterruptibly）
- 不可中断的获取方法（acquire）
- 中断状态会在获取成功后补上
java复制final boolean acquireQueued(final Node node, int arg) {
boolean interrupted = false;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} catch (Throwable t) {
cancelAcquire(node);
throw t;
}
}
6.3 公平性与非公平性实现
公平锁与非公平锁的主要区别在于tryAcquire实现：
公平锁：
java复制protected final boolean tryAcquire(int acquires) {
// ...检查队列中是否有等待线程
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
// ...
}
非公平锁：
java复制final boolean nonfairTryAcquire(int acquires) {
// 直接尝试获取，不管队列情况
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
// ...
}
在实际应用中，非公平锁通常有更高的吞吐量，但可能导致线程饥饿。
7. AQS在JUC中的典型应用
7.1 ReentrantLock的实现
ReentrantLock是AQS最典型的应用之一，其内部通过Sync抽象类继承AQS：
java复制public class ReentrantLock implements Lock {
abstract static class Sync extends AbstractQueuedSynchronizer {
// 实现细节...
}
static final class NonfairSync extends Sync {
// 非公平锁实现
}
static final class FairSync extends Sync {
// 公平锁实现
}
}
7.2 CountDownLatch的工作原理
CountDownLatch使用AQS的共享模式实现：
java复制public class CountDownLatch {
private static final class Sync extends AbstractQueuedSynchronizer {
Sync(int count) {
setState(count);
}
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
protected boolean tryReleaseShared(int releases) {
// 递减计数，直到0
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}
}
7.3 Semaphore的并发控制
Semaphore同样基于AQS共享模式实现：
java复制public class Semaphore {
abstract static class Sync extends AbstractQueuedSynchronizer {
Sync(int permits) {
setState(permits);
}
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
}
}
8. AQS性能优化与最佳实践
8.1 减少锁竞争的策略
- 锁分解：将一个大锁拆分为多个小锁
- 锁粗化：在合理情况下合并多个小锁
- 读写分离：使用ReadWriteLock替代独占锁
- 乐观并发控制：尝试使用StampedLock
8.2 避免常见性能陷阱
- 避免在持有锁时执行耗时操作
- 注意锁的粒度：过细可能导致过多锁开销
- 警惕嵌套锁：容易导致死锁和性能问题
- 合理设置超时：避免无限期等待
8.3 监控与诊断工具
- JConsole/VisualVM：监控线程状态和锁竞争
- JFR(Java Flight Recorder)：记录详细的锁事件
- Async Profiler：分析锁争用的热点
- JMH：对同步代码进行基准测试
9. AQS与Java并发模型的演进
9.1 Java内存模型与AQS
AQS的实现严格遵循Java内存模型(JMM)规范：
- 所有状态变更使用volatile变量
- 通过unsafe类保证CAS操作的原子性
- 正确建立happens-before关系
9.2 VarHandle与AQS的现代化改造
Java 9引入了VarHandle，可以替代部分Unsafe操作：
java复制// 传统方式
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
static {
try {
stateOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("state"));
} catch (Exception ex) { throw new Error(ex); }
}
// VarHandle方式
private static final VarHandle STATE;
static {
try {
MethodHandles.Lookup l = MethodHandles.lookup();
STATE = l.findVarHandle(AbstractQueuedSynchronizer.class, "state", int.class);
} catch (ReflectiveOperationException e) {
throw new Error(e);
}
}
9.3 虚拟线程(Loom)对AQS的影响
随着Java虚拟线程的引入，AQS的实现可能需要调整：
- 虚拟线程不应被park/unpark
- 需要新的调度机制
- 但基本设计理念仍然适用
在实际项目中，我发现理解AQS的底层原理对于诊断复杂的并发问题非常有帮助。曾经遇到过一个性能问题，表面上看是数据库连接池的瓶颈，但通过分析线程dump发现实际上是自定义锁实现不当导致的。深入理解AQS后，我们重写了同步逻辑，性能提升了近3倍。