## 引言：并发世界的“隐形基石”


在 Java 并发编程的浩瀚宇宙中，`java.util.concurrent`（JUC）包犹如一座精密运转的机械钟表，而其核心齿轮正是 **Doug Lea** 设计的 `AbstractQueuedSynchronizer`（AQS）。然而，在 AQS 的璀璨光芒之下，还隐藏着一位低调却至关重要的“孪生兄弟”——`AbstractQueuedLongSynchronizer`（AQLS）。本文将带你深入 AQLS 的源码腹地，逐行剖析其设计精髓、实现细节与工程价值，揭开这个 64 位同步器框架的神秘面纱。

>💡 **你是否好奇：为什么 Java 要专门为 `long` 状态设计一个独立的同步器框架？它和 AQS 到底有何异同？欢迎在评论区留下你的疑问！如果本文助你攻克并发难题，别忘了点赞+收藏，让更多开发者受益！**


----

## 第一章：AQLS 的诞生背景与核心定位


### 1.1 从 AQS 到 AQLS：状态空间的扩展需求


`AbstractQueuedSynchronizer`（AQS）作为 JUC 包的基石，为 `ReentrantLock`、`Semaphore`、`CountDownLatch` 等同步工具提供了统一的底层框架。其核心是一个 `volatile int state` 字段，用于表示同步状态（如锁的持有次数、信号量的许可数等）。

然而，**32 位的 `int` 状态在某些高级场景下显得捉襟见肘**：


- **读写锁优化**：需要同时记录高 32 位的读锁计数和低 32 位的写锁计数；

- **超大容量信号量**：许可数可能超过 `Integer.MAX_VALUE`（约 21 亿）；

- **复合状态编码**：需用 64 位空间存储更复杂的同步信息（如时间戳+计数器）。


为解决这一瓶颈，Doug Lea 在 JUC 中引入了 `AbstractQueuedLongSynchronizer`（AQLS），**将同步状态从 `int` 扩展为 `long`**，从而提供更大的状态表示能力。

### 1.2 AQLS 的官方定义与继承体系


AQLS 的类声明如下：

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

- **父类**：`AbstractOwnableSynchronizer`，提供独占模式下的线程归属记录（`exclusiveOwnerThread`）；

- **接口**：`Serializable`，支持序列化（尽管实际使用中较少序列化同步器）；

- **包位置**：`java.util.concurrent.locks`，与 AQS 同属一个包。


>📌 **关键区别**：AQLS 与 AQS **功能完全一致**，唯一差异在于状态字段类型（`long` vs `int`）及相应的方法签名。


----

## 第二章：AQLS 核心数据结构详解


### 2.1 同步状态：`state` 字段


AQLS 的核心是 `volatile long state` 字段：

```
private volatile long state;

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

- **`volatile` 修饰**：保证多线程间的可见性；

- **`compareAndSetState`**：基于 `Unsafe` 的 CAS 操作，确保状态更新的原子性；

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


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


AQLS 内部维护一个 **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;         // 下一个等待者（用于共享/独占模式标记或条件队列）

    // 构造函数
    Node() {}
    Node(Thread thread, Node mode) { this.nextWaiter = mode; this.thread = thread; }
    Node(Thread thread, int waitStatus) { U.putObject(this, WAITSTATUS, waitStatus); this.thread = thread; }
}
```

- **双向链表**：`prev` 和 `next` 指针支持高效的前驱/后继操作；

- **`waitStatus`**：控制节点行为（如是否需唤醒后继）；

- **`nextWaiter`**：双重用途——既是模式标记（`SHARED`/`EXCLUSIVE`），也是条件队列的单向链表指针。


#### 队列头尾指针


```
private transient volatile Node head; // 队列头（当前持有资源的节点）
private transient volatile Node tail; // 队列尾（最新加入的等待节点）
```

- **`transient`**：不参与序列化；

- **`volatile`**：保证多线程可见性。


### 2.3 条件队列：`ConditionObject`


AQLS 支持条件等待（类似 `Object.wait()`/`notify()`），通过内部类 `ConditionObject` 实现：

```
public class ConditionObject implements Condition, java.io.Serializable {
    private transient Node firstWaiter; // 条件队列头
    private transient Node lastWaiter;  // 条件队列尾

    // 核心方法：await(), signal(), signalAll()
}
```

- **单向链表**：条件队列使用 `nextWaiter` 构建单向链表；

- **与同步队列分离**：调用 `await()` 时，节点从同步队列移至条件队列；`signal()` 则将其移回同步队列。


----

## 第三章：AQLS 核心算法流程深度剖析


### 3.1 独占模式（Exclusive Mode）


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


```
public final void acquire(long arg) {
    if (!tryAcquire(arg) && // 尝试获取资源（子类实现）
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // 加入队列并自旋等待
        selfInterrupt(); // 如果等待过程中被中断，则恢复中断状态
}
```
**流程分解**：


1. **`tryAcquire(arg)`**：子类重写的钩子方法，尝试以独占模式获取资源；

2. **失败则入队**：调用 `addWaiter(Node.EXCLUSIVE)` 创建新节点并加入队列尾部；

3. **自旋等待**：`acquireQueued` 在队列中循环尝试获取资源，若前驱是头节点则再次调用 `tryAcquire`；

4. **中断处理**：若等待期间被中断，记录中断状态并在最后恢复。


#### `addWaiter`：高效入队算法


```
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)) { // CAS 设置新尾节点
                oldTail.next = node; // 链接后继
                return node;
            }
        } else {
            initializeSyncQueue(); // 初始化空队列
        }
    }
}
```

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

- **`setPrevRelaxed`**：使用 `Unsafe.putObject` 非 volatile 写入 `prev`，提升性能（因后续 CAS 成功才生效）。


#### `acquireQueued`：自旋获取资源


```
final boolean acquireQueued(final Node node, long 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(long arg)`


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

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


### 3.2 共享模式（Shared Mode）


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


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

- **`tryAcquireShared` 返回值语义**：
	- **负值**：获取失败；
	- **0**：获取成功，但无后续节点可唤醒；
	- **正值**：获取成功，且可唤醒后续共享节点。


#### `doAcquireShared`：共享模式入队


```
private void doAcquireShared(long 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; // help GC
                if (interrupted)
                    selfInterrupt();
                return;
            }
        }
        if (shouldParkAfterFailedAcquire(p, node) &&
            parkAndCheckInterrupt())
            interrupted = true;
    }
}
```

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


#### 释放资源：`releaseShared(long arg)`


```
public final boolean releaseShared(long arg) {
    if (tryReleaseShared(arg)) { // 尝试释放（子类实现）
        doReleaseShared(); // 传播释放信号
        return true;
    }
    return false;
}
```

- **`doReleaseShared`**：循环唤醒后继共享节点，直到队列为空或遇到独占节点。


----

## 第四章：AQLS 与 AQS 的全面对比


|特性|`AbstractQueuedSynchronizer`(AQS)|`AbstractQueuedLongSynchronizer`(AQLS)|
|:-:|:-:|:-:|
|**状态类型**|`volatile int state`|`volatile long state`|
|**CAS 方法**|`compareAndSetState(int, int)`|`compareAndSetState(long, long)`|
|**获取方法**|`acquire(int)`, `acquireShared(int)`|`acquire(long)`, `acquireShared(long)`|
|**释放方法**|`release(int)`, `releaseShared(int)`|`release(long)`, `releaseShared(long)`|
|**适用场景**|常规同步器（锁、信号量等）|需要 64 位状态的高级同步器|
|**使用频率**|极高（JUC 核心）|较低（特定需求）|

>⚠️ **重要提示**：AQLS **并未被 JUC 内置类直接使用**（截至 JDK 21），而是为开发者提供自定义同步器的扩展选项。


----

## 第五章：自定义同步器实战——基于 AQLS 的 64 位读写锁


### 5.1 设计思路


利用 `long` 状态的 64 位空间：


- **高 32 位**：存储读锁计数（最多约 42 亿次）；

- **低 32 位**：存储写锁计数（0 或 1）。


### 5.2 核心代码实现


```
public class LongStampedReadWriteLock extends AbstractQueuedLongSynchronizer {
    private static final long READ_MASK = 0xFFFFFFFF00000000L;
    private static final long WRITE_MASK = 0x00000000FFFFFFFFL;
    private static final long UNIT = 1L << 32; // 读锁单位（1 << 32）

    // 获取读锁计数
    private long readCount(long state) { return state >>> 32; }
    // 获取写锁计数
    private long writeCount(long state) { return state & WRITE_MASK; }

    @Override
    protected boolean tryAcquire(long acquires) {
        long current = getState();
        long w = writeCount(current);
        if (w != 0 || current == 0) { // 有写锁或无任何锁
            if (compareAndSetState(current, current + 1))
                return true;
        }
        return false;
    }

    @Override
    protected boolean tryRelease(long releases) {
        long current = getState();
        if (writeCount(current) == 0)
            throw new IllegalMonitorStateException();
        setState(current - 1);
        return true;
    }

    @Override
    protected long tryAcquireShared(long acquires) {
        for (;;) {
            long current = getState();
            long w = writeCount(current);
            if (w != 0 && getExclusiveOwnerThread() != Thread.currentThread())
                return -1; // 有写锁且非当前线程
            long r = readCount(current);
            if (r == READ_MASK >>> 32) // 读锁溢出
                throw new Error("Maximum lock count exceeded");
            if (compareAndSetState(current, current + UNIT))
                return 1; // 成功获取读锁
        }
    }

    @Override
    protected boolean tryReleaseShared(long releases) {
        for (;;) {
            long current = getState();
            long next = current - UNIT;
            if (compareAndSetState(current, next))
                return next >>> 32 == 0; // 无读锁则返回 true
        }
    }

    // 公共 API
    public void readLock() { acquireShared(1); }
    public void readUnlock() { releaseShared(1); }
    public void writeLock() { acquire(1); }
    public void writeUnlock() { release(1); }
}
```
### 5.3 使用示例


```
LongStampedReadWriteLock lock = new LongStampedReadWriteLock();

// 读线程
new Thread(() -> {
    lock.readLock();
    try { /* 读操作 */ }
    finally { lock.readUnlock(); }
}).start();

// 写线程
new Thread(() -> {
    lock.writeLock();
    try { /* 写操作 */ }
    finally { lock.writeUnlock(); }
}).start();
```
>🚀 **你会用 AQLS 实现什么创新同步器？是在高并发系统中优化读写锁，还是设计超大容量信号量？快在评论区分享你的创意！如果觉得本文干货满满，记得点赞、收藏，并转发给需要的同事——一起攻克 Java 并发难题！**


----

## 第六章：AQLS 的性能与局限性分析


### 6.1 性能优势


- **更大的状态空间**：避免 `int` 溢出问题，支持更复杂的同步逻辑；

- **与 AQS 相同的高效队列**：CLH 队列的低开销、公平性保障；

- **CAS 优化**：`long` 的 CAS 在 64 位 JVM 上与 `int` 性能相当。


### 6.2 局限性


- **未被 JUC 内置类采用**：缺乏官方参考实现，学习成本较高；

- **内存占用略增**：`long` 状态比 `int` 多 4 字节（通常可忽略）；

- **适用场景有限**：多数应用无需 64 位状态，AQS 已足够。


### 6.3 最佳实践建议


1. **优先使用 AQS**：除非明确需要 64 位状态，否则选择更成熟的 AQS；

2. **谨慎设计状态编码**：确保 `long` 状态的位操作清晰、无冲突；

3. **充分测试边界条件**：如状态溢出、高并发竞争等场景。


----

## 结语：站在巨人的肩膀上


`AbstractQueuedLongSynchronizer` 虽不如 AQS 广为人知，却是 Doug Lea 为 Java 并发世界预留的一把“瑞士军刀”。它体现了 JUC 框架的**前瞻性与扩展性**——在满足主流需求的同时，为特殊场景提供底层支持。理解 AQLS 不仅能提升你对同步器原理的认知，更能激发你在高并发系统设计中的创新思维。

正如 Doug Lea 在其论文《The java.util.concurrent Synchronizer Framework》中所言：“**A good framework should be simple enough to use, yet powerful enough to build complex synchronizers.**” AQLS 正是这一理念的完美诠释。

>**你准备好用 AQLS 构建自己的高性能同步器了吗？在评论区留下你的想法，点赞、收藏、分享，让这篇万字精解帮助更多 Java 开发者登顶并发之巅！**

在 Java 并发编程的浩瀚宇宙中，java.util.concurrent（JUC）包犹如一座精密运转的机械钟表，而其核心齿轮正是 Doug Lea 设计的 AbstractQueuedSynchronizer（AQS）。然而，在 AQS 的璀璨光芒之下，还隐藏着一位低调却至关重要的“孪生兄弟”——AbstractQueuedLongSynchronizer（AQLS）。本文将带你深入 AQLS 的源码腹地，逐行剖析其设计精髓、实现细节与工程价值，揭开这个 64 位同步器框架的神秘面纱。

Java源码分析:AbstractQueuedLongSynchronizer 源码万字精解：从 Doug Lea 的设计哲学到 64 位同步器实战

在 Java 并发编程的浩瀚宇宙中，java.util.concurrent（JUC）包犹如一座精密运转的机械钟表，而其核心齿轮正是 Doug Lea 设计的 AbstractQueuedSynchronizer（AQS）。然而，在 AQS 的璀璨光芒之下，还隐藏着一位低调却至关重要的“孪生兄弟”——AbstractQueuedLongSynchronizer（AQLS）。

后端

编程语言

架构设计

Java并发编程中的AbstractQueuedLongSynchronizer（AQLS）是AQS的64位扩展，支持更大状态空间，适用于读写锁优化、超大容量信号量等高级场景。本文深度解析AQLS的设计原理、核心算法及实战应用，帮助开发者掌握这一高性能同步器框架，解决复杂并发问题。

数据结构

Java

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

llmsgw

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

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

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

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

社区新版编辑器体验调研

Java源码分析:AbstractQueuedLongSynchronizer 源码万字精解：从 Doug Lea 的设计哲学到 64 位同步器实战-腾讯云开发者社区-腾讯云

Java源码分析:AbstractQueuedLongSynchronizer 源码万字精解：从 Doug Lea 的设计哲学到 64 位同步器实战

Java源码分析:AbstractQueuedLongSynchronizer 源码万字精解：从 Doug Lea 的设计哲学到 64 位同步器实战

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐