
## 引言：Java 并发世界的“地基之王”


如果说 `java.util.concurrent`（JUC）包是 Java 并发编程的摩天大楼，那么 **`AbstractQueuedSynchronizer`**（AQS）无疑是这座大厦最深、最稳的地基。由并发大师 **Doug Lea** 于 JDK 5 时代亲手打造，AQS 以不到 2000 行代码，支撑起了 `ReentrantLock`、`Semaphore`、`CountDownLatch` 等数十个核心并发工具。它不仅是 JUC 的灵魂，更是无数开发者理解高并发系统设计的必经之路。

>💡 **你是否曾困惑：为什么 AQS 能成为如此多同步器的基石？它的队列机制如何保证公平性与高性能？欢迎在评论区留下你的思考！如果本文助你打通并发任督二脉，别忘了点赞+收藏，让更多开发者站在巨人的肩膀上！**


----

## 第一章：AQS 的起源与历史使命


### 1.1 诞生背景：从 synchronized 到显式锁


在 JDK 5 之前，Java 开发者只能依赖 `synchronized` 关键字实现线程同步。虽然简单，但其局限性日益凸显：


- **不可中断**：线程在等待锁时无法响应中断；

- **不可超时**：无法设置获取锁的最大等待时间；

- **非公平性**：无法保证先到先得的公平调度；

- **单一语义**：仅支持互斥，难以扩展为读写锁、信号量等。


Doug Lea 在 JSR-166 规范中提出 JUC 包，旨在提供一套**灵活、高效、可扩展**的并发工具。而 AQS 正是这一愿景的核心——一个**通用的同步器框架**，让开发者无需重复造轮子，只需关注业务逻辑。

### 1.2 设计目标：简化同步器开发


AQS 的设计哲学可概括为：


- **抽象共性**：将线程排队、阻塞、唤醒等复杂逻辑封装；

- **开放扩展**：通过模板方法模式，允许子类定义资源获取/释放规则；

- **性能优先**：基于 CAS 和 FIFO 队列，最小化上下文切换开销。


正如 Doug Lea 在其论文《The java.util.concurrent Synchronizer Framework》中所述：“**A good framework should hide the complexity of synchronization while exposing the flexibility to build diverse synchronizers.**”


----

## 第二章：AQS 的核心定义与架构


### 2.1 类声明与继承体系


AQS 的完整类声明如下：

```
public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    // ...
}
```

- **继承 AOS**：获得独占模式下的线程所有权记录能力（`exclusiveOwnerThread`）；

- **抽象类**：不能直接实例化，需子类实现核心逻辑；

- **序列化支持**：虽实现 `Serializable`，但实际使用中极少序列化同步器。


### 2.2 三大核心组件


AQS 的架构围绕三个核心组件展开：


|组件|作用|关键字段/方法|
|:-:|:-:|:-:|
|**同步状态**（State）|表示资源的可用性（如锁计数、信号量许可数）|`volatile int state`, `getState()`, `setState()`, `compareAndSetState()`|
|**同步队列**（Sync Queue）|FIFO 双向队列，管理等待获取资源的线程|`head`, `tail`, `Node` 内部类|
|**条件队列**（Condition Queue）|单向链表，管理因条件不满足而等待的线程|`ConditionObject`, `firstWaiter`, `lastWaiter`|

>📌 **关键关系**：同步状态决定资源是否可用；同步队列处理竞争；条件队列处理协作。


----

## 第三章：AQS 源码逐行深度剖析


### 3.1 同步状态：原子整数的魔法


AQS 使用 `volatile int state` 表示同步状态：

```
private volatile int state;

protected final int getState() { return state; }
protected final void setState(int newState) { state = newState; }
protected final boolean compareAndSetState(int expect, int update) {
    return U.compareAndSwapInt(this, STATE, expect, update);
}
```

- **`volatile` 保证可见性**：多线程修改后立即对其他线程可见；

- **CAS 保证原子性**：`compareAndSetState` 是所有状态变更的基础；

- **内存偏移量 `STATE`**：通过 `Unsafe.objectFieldOffset` 静态初始化。


### 3.2 同步队列：CLH 队列的双向链表实现


AQS 内部维护一个 **FIFO 双向队列**（CLH 队列变体），节点由内部类 `Node` 定义：

#### Node 结构详解


```
static final class Node {
    static final Node SHARED = new Node(); // 共享模式标记
    static final Node EXCLUSIVE = null;    // 独占模式标记

    static final int CANCELLED =  1; // 线程已取消
    static final int SIGNAL    = -1; // 后继需被唤醒
    static final int CONDITION = -2; // 在条件队列中
    static final int PROPAGATE = -3; // 共享模式需传播

    volatile int waitStatus; // 等待状态
    volatile Node prev;      // 前驱节点
    volatile Node next;      // 后继节点
    volatile Thread thread;  // 关联线程
    Node nextWaiter;         // 下一个等待者（模式标记或条件队列指针）
}
```

- **双向链表**：`prev` 和 `next` 支持高效遍历；

- **`waitStatus` 控制行为**：如 `SIGNAL` 表示前驱承诺唤醒后继；

- **虚拟头节点**：队列初始化时创建空头节点，避免边界检查。


#### 队列操作：入队与出队


```
// 入队：高效尾插
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    for (;;) {
        Node oldTail = tail;
        if (oldTail != null) {
            node.setPrevRelaxed(oldTail); // relaxed 写入 prev
            if (compareAndSetTail(oldTail, node)) {
                oldTail.next = node; // 链接后继
                return node;
            }
        } else {
            initializeSyncQueue(); // 初始化空队列
        }
    }
}

// 出队：设置新头
private void setHead(Node node) {
    head = node;
    node.thread = null;
    node.prev = null;
}
```

- **CAS 保证线程安全**：`compareAndSetTail` 确保尾节点更新原子性；

- **`setPrevRelaxed` 优化**：非 volatile 写入 `prev`，提升性能（因后续 CAS 成功才生效）。


### 3.3 独占模式：从 acquire 到 release


#### 获取资源：`acquire(int arg)`


```
public final void acquire(int arg) {
    if (!tryAcquire(arg) && // 尝试获取（子类实现）
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // 入队并自旋
        selfInterrupt(); // 恢复中断状态
}
```
**核心流程**：


1. **`tryAcquire`**：子类定义获取规则（如重入锁检查持有者）；

2. **失败则入队**：调用 `addWaiter` 创建节点并加入队列尾；

3. **自旋等待**：`acquireQueued` 循环尝试获取，若前驱是头节点则重试；

4. **中断处理**：记录中断状态并在最后恢复。


#### `acquireQueued`：自旋与阻塞的艺术


```
final boolean acquireQueued(final Node node, int arg) {
    boolean interrupted = false;
    for (;;) {
        final Node p = node.predecessor();
        if (p == head && tryAcquire(arg)) { // 前驱是头且获取成功
            setHead(node); // 当前节点成为新头
            p.next = null; // 断开旧头引用（帮助 GC）
            return interrupted;
        }
        if (shouldParkAfterFailedAcquire(p, node) && // 检查是否需阻塞
            parkAndCheckInterrupt()) // 阻塞线程
            interrupted = true;
    }
}
```

- **`shouldParkAfterFailedAcquire`**：根据前驱 `waitStatus` 决定是否阻塞（若为 `SIGNAL` 则安全阻塞）；

- **`parkAndCheckInterrupt`**：调用 `LockSupport.park()` 阻塞，并返回中断状态。


#### 释放资源：`release(int arg)`


```
public final boolean release(int arg) {
    if (tryRelease(arg)) { // 尝试释放（子类实现）
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h); // 唤醒后继
        return true;
    }
    return false;
}
```

- **`unparkSuccessor`**：从后往前查找第一个非取消节点并唤醒（避免 `next` 指针延迟更新导致漏唤醒）。


### 3.4 共享模式：无惊群的传播唤醒


#### 获取资源：`acquireShared(int arg)`


```
public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0) // 尝试获取（返回值<0表示失败）
        doAcquireShared(arg); // 入队等待
}
```

- **返回值语义**：
	- **负值**：失败；
	- **0**：成功但无后续可唤醒；
	- **正值**：成功且可唤醒后续。


#### `doAcquireShared`：共享入队与传播


```
private void doAcquireShared(int arg) {
    final Node node = addWaiter(Node.SHARED);
    boolean interrupted = false;
    for (;;) {
        final Node p = node.predecessor();
        if (p == head) {
            long r = tryAcquireShared(arg);
            if (r >= 0) {
                setHeadAndPropagate(node, r); // 设置新头并传播
                p.next = null;
                if (interrupted) selfInterrupt();
                return;
            }
        }
        if (shouldParkAfterFailedAcquire(p, node) &&
            parkAndCheckInterrupt())
            interrupted = true;
    }
}
```

- **`setHeadAndPropagate`**：关键优化！若剩余资源充足（`r > 0`），则继续唤醒后续共享节点，避免“惊群效应”。


----

## 第四章：AQS 的设计模式与哲学


### 4.1 模板方法模式（Template Method）


AQS 是模板方法模式的典范：


- **定义骨架**：`acquire/release` 等 final 方法定义流程；

- **开放钩子**：`tryAcquire/tryRelease` 等 protected 方法由子类实现；

- **控制反转**：框架控制流程，子类提供策略。


例如，`ReentrantLock.NonfairSync` 实现：

```
protected boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current); // ← AOS 的调用
            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;
}
```
### 4.2 单一职责与高内聚


- **AQS 专注同步**：只处理线程排队、阻塞、唤醒；

- **状态管理分离**：同步状态由子类解释（如锁计数、许可数）；

- **所有权委托 AOS**：线程持有者记录由父类 `AbstractOwnableSynchronizer` 负责。


### 4.3 性能优化哲学


- **无锁化**：大量使用 CAS 避免重量级锁；

- **懒加载**：队列仅在竞争时初始化；

- **内存友好**：`prev` 的 relaxed 写入减少内存屏障开销。


----

## 第五章：AQS 的使用场景分析


### 5.1 合适使用场景


#### （1）自定义锁


- **可重入锁**：如 `ReentrantLock`，支持公平/非公平模式；

- **读写锁**：`ReentrantReadWriteLock`，分离读/写状态；

- **StampedLock**：乐观读优化，AQS 用于悲观模式。


#### （2）同步工具


- **信号量**（Semaphore）：管理固定数量的许可；

- **倒计时门闩**（CountDownLatch）：等待 N 个事件完成；

- **循环栅栏**（CyclicBarrier）：虽内部用 `ReentrantLock`，但本质依赖 AQS。


#### （3）高级并发容器


- **阻塞队列**：如 `LinkedBlockingQueue`，用 `ReentrantLock` 保护队列；

- **FutureTask**：JDK 7 前版本用 AQS 实现任务状态管理。


### 5.2 不合适使用场景


#### （1）简单互斥


- **场景**：单次临界区保护；

- **替代方案**：直接使用 `synchronized`，更简洁且 JVM 优化更好。


#### （2）无竞争场景


- **场景**：低并发或单线程环境；

- **问题**：AQS 的队列和 CAS 开销反而成为负担。


#### （3）非阻塞算法


- **场景**：需要完全无锁的高性能场景（如 Disruptor）；

- **替代方案**：使用 `AtomicReference`、`VarHandle` 等构建无锁数据结构。


----

## 第六章：同类比较——AQS vs 其他同步机制


|特性|`synchronized`|`ReentrantLock`(AQS)|`StampedLock`|`Phaser`|
|:-:|:-:|:-:|:-:|:-:|
|**实现基础**|JVM intrinsic|AQS|AQS + 乐观读|AQS + 动态阶段|
|**可中断**|否|是|是|是|
|**超时支持**|否|是|是|是|
|**公平性**|无|可选|无|可选|
|**读写分离**|否|是（通过 RWLock）|是|否|
|**性能**|JVM 优化极佳|高（显式控制）|极高（乐观读）|高（动态调整）|

>⚠️ **关键结论**：AQS 不是万能药，而是**复杂同步需求的利器**。简单场景优先 `synchronized`，复杂场景再考虑 AQS。


----

## 第七章：云原生与 AI Agent 时代的挑战与演进


### 7.1 云原生环境下的挑战


#### （1）高并发与弹性伸缩


- **挑战**：微服务实例动态扩缩容，锁竞争模式瞬息万变；

- **演进**：AQS 集成 **自适应策略**，如根据负载自动切换公平/非公平模式。


#### （2）可观测性需求


- **挑战**：分布式系统需追踪锁持有链路；

- **演进**：扩展 AQS 记录 **TraceID** 而非仅 `Thread`，与 OpenTelemetry 集成。


#### （3）资源效率


- **挑战**：容器化环境 CPU/内存受限；

- **演进**：优化 AQS 内存布局，减少 `Node` 对象开销（如对象池化）。


### 7.2 AI Agent 时代的机遇


#### （1）智能锁调度


- **场景**：AI Agent 协调多任务访问共享资源；

- **演进**：AQS 扩展为 **Agent-Aware Synchronizer**，支持基于 Agent 优先级的调度。


#### （2）预测性同步


- **场景**：AI 预测资源竞争热点；

- **演进**：AQS 集成 **预测模型**，提前预热队列或调整状态。


#### （3）跨语言协同


- **场景**：Java Agent 与 Python/C++ 模块协作；

- **演进**：AQS 提供 **FFI**（Foreign Function Interface），支持跨语言锁语义。


### 7.3 Project Loom 与虚拟线程


Project Loom 的 **虚拟线程**（Virtual Threads）将颠覆传统并发模型：


- **海量并发**：百万级虚拟线程，传统 AQS 队列可能成为瓶颈；

- **AQS 的演进方向**：
	- **轻量级队列**：为虚拟线程设计更紧凑的 `Node` 结构；
	- **结构化并发集成**：与 `StructuredTaskScope` 协同，自动管理锁生命周期；
	- **Continuation 感知**：记录 Continuation 而非平台线程，支持跨挂起点的锁持有。


----

## 结语：永恒的设计，持续的演进


`AbstractQueuedSynchronizer` 自诞生以来，历经近 20 年考验，依然是 Java 并发领域最优雅、最强大的设计之一。它用极简的代码，解决了最复杂的线程同步问题，体现了 Doug Lea “**Simple, Correct, Fast — in that order**” 的工程哲学。

在云原生与 AI Agent 时代，AQS 并未过时，而是在不断演进。无论是与虚拟线程的融合，还是与智能调度的结合，AQS 的核心思想——**抽象共性、开放扩展、性能优先**——将继续指引并发编程的未来。

>**你认为 AQS 在未来十年会如何演变？是在 Loom 时代焕发新生，还是被全新的同步范式取代？快在评论区分享你的洞见！如果觉得本文助你深入理解 AQS，记得点赞、收藏，并转发给团队伙伴——一起构建更强大的并发系统！**

如果说 java.util.concurrent（JUC）包是 Java 并发编程的摩天大楼，那么 AbstractQueuedSynchronizer（AQS）无疑是这座大厦最深、最稳的地基。由并发大师 Doug Lea 于 JDK 5 时代亲手打造，AQS 以不到 2000 行代码，支撑起了 ReentrantLock、Semaphore、CountDownLatch 等数十个核心并发工具。它不仅是 JUC 的灵魂，更是无数开发者理解高并发系统设计的必经之路。

Java源码详解：深入Java JUC包之AbstractQueuedSynchronizer 源码万字精解—Doug Lea 的并发艺术与云原生时代的演进

如果说 java.util.concurrent（JUC）包是 Java 并发编程的摩天大楼，那么 AbstractQueuedSynchronizer（AQS）无疑是这座大厦最深、最稳的地基。由并发大师 Doug Lea 于 JDK 5 时代亲手打造，AQS 以不到 2000 行代码，支撑起了 ReentrantLock、Semaphore、CountDownLatch 等数十个核心并发工具。

后端

编程语言

架构设计

Java并发编程核心AbstractQueuedSynchronizer（AQS）深度解析：从CLH队列设计、独占/共享模式源码剖析，到ReentrantLock/Semaphore等JUC工具实现原理。详解CAS状态控制、模板方法模式及高性能同步器设计哲学，助力开发者掌握高并发系统底层架构。

弹性伸缩

数据结构

云原生

容器

Python

Agent

Java

2026采购季 | AI焕新·智启新局

llmsgw

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

Java源码详解：深入Java JUC包之AbstractQueuedSynchronizer 源码万字精解—Doug Lea 的并发艺术与云原生时代的演进-腾讯云开发者社区-腾讯云

Java源码详解：深入Java JUC包之AbstractQueuedSynchronizer 源码万字精解—Doug Lea 的并发艺术与云原生时代的演进

Java源码详解：深入Java JUC包之AbstractQueuedSynchronizer 源码万字精解—Doug Lea 的并发艺术与云原生时代的演进

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐