如何理解AQS源码

发布时间：2021-10-19 16:42:17 作者：iii
来源：亿速云阅读：169

# 如何理解AQS源码

## 目录
1. [AQS概述](#1-aqs概述)  
   1.1 [什么是AQS](#11-什么是aqs)  
   1.2 [AQS的核心思想](#12-aqs的核心思想)  
   1.3 [AQS的应用场景](#13-aqs的应用场景)  
2. [AQS核心数据结构](#2-aqs核心数据结构)  
   2.1 [同步状态state](#21-同步状态state)  
   2.2 [CLH队列](#22-clh队列)  
   2.3 [Node节点解析](#23-node节点解析)  
3. [独占模式源码分析](#3-独占模式源码分析)  
   3.1 [acquire流程](#31-acquire流程)  
   3.2 [release流程](#32-release流程)  
4. [共享模式源码分析](#4-共享模式源码分析)  
   4.1 [acquireShared流程](#41-acquireshared流程)  
   4.2 [releaseShared流程](#42-releaseshared流程)  
5. [条件队列实现原理](#5-条件队列实现原理)  
   5.1 [ConditionObject结构](#51-conditionobject结构)  
   5.2 [await实现机制](#52-await实现机制)  
   5.3 [signal实现机制](#53-signal实现机制)  
6. [AQS设计模式分析](#6-aqs设计模式分析)  
   6.1 [模板方法模式应用](#61-模板方法模式应用)  
   6.2 [CLH队列变体](#62-clh队列变体)  
7. [常见同步器实现分析](#7-常见同步器实现分析)  
   7.1 [ReentrantLock](#71-reentrantlock)  
   7.2 [CountDownLatch](#72-countdownlatch)  
   7.3 [Semaphore](#73-semaphore)  
8. [AQS性能优化策略](#8-aqs性能优化策略)  
   8.1 [自旋优化](#81-自旋优化)  
   8.2 [队列头尾竞争优化](#82-队列头尾竞争优化)  
9. [AQS面试深度剖析](#9-aqs面试深度剖析)  
10. [总结与最佳实践](#10-总结与最佳实践)  

---

## 1. AQS概述

### 1.1 什么是AQS
AbstractQueuedSynchronizer（AQS）是Java并发包中的核心框架，自JDK1.5引入，位于`java.util.concurrent.locks`包下。作为构建锁和同步器的基石，其设计采用模板方法模式，通过继承方式实现自定义同步控制。

```java
public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer {
    // 同步状态字段
    private volatile int state;
    // CLH队列头节点
    private transient volatile Node head;
    // CLH队列尾节点
    private transient volatile Node tail;
}

1.2 AQS的核心思想

状态管理：通过volatile变量state表示资源状态
队列管理：采用CLH变体队列处理线程排队
模板方法：定义tryAcquire/tryRelease等待实现方法

1.3 AQS的应用场景

独占锁：ReentrantLock
共享锁：Semaphore/CountDownLatch
混合模式：ReentrantReadWriteLock

2. AQS核心数据结构

2.1 同步状态state

// 使用CAS保证原子性更新
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

状态含义取决于实现： - ReentrantLock：表示重入次数 - Semaphore：表示可用许可数

2.2 CLH队列

CLH（Craig, Landin, Hagersten）队列变体特点： 1. 双向链表结构 2. 通过前驱节点的status进行自旋避免竞争 3. 头部节点为虚节点（dummy node）

2.3 Node节点解析

static final class Node {
    // 节点模式
    static final Node SHARED = new Node();
    static final Node EXCLUSIVE = null;
    
    // 等待状态
    volatile int waitStatus;
    static final int CANCELLED =  1;
    static final int SIGNAL    = -1;
    
    // 前后指针
    volatile Node prev;
    volatile Node next;
    
    // 关联线程
    volatile Thread thread;
}

3. 独占模式源码分析

3.1 acquire流程

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

tryAcquire：子类实现获取逻辑
addWaiter：创建节点并入队
acquireQueued：队列中自旋获取资源

3.2 release流程

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唤醒后继节点 - 保证唤醒传播性

4. 共享模式源码分析

4.1 acquireShared流程

public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

与独占模式区别： - 返回值表示剩余资源量 - 使用setHeadAndPropagate传播唤醒

4.2 releaseShared流程

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

通过自旋保证： - 稳定状态传播 - 处理竞争情况

5. 条件队列实现原理

5.1 ConditionObject结构

public class ConditionObject implements Condition {
    private transient Node firstWaiter;
    private transient Node lastWaiter;
}

与同步队列关系： - 共享state状态 - 节点类型不同（CONDITION=-2）

5.2 await实现机制

创建CONDITION节点加入条件队列
完全释放同步状态
被signal后重新竞争锁

5.3 signal实现机制

public final void signal() {
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    Node first = firstWaiter;
    if (first != null)
        doSignal(first);
}

关键步骤： - 转移节点到同步队列 - 修改waitStatus状态

6. AQS设计模式分析

6.1 模板方法模式应用

需要子类实现的方法：

protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

6.2 CLH队列变体优化

改进点： 1. 显式维护前驱指针 2. 增加超时/Cancellation处理 3. 虚拟头节点减少竞争

7. 常见同步器实现分析

7.1 ReentrantLock

公平锁实现：

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 处理重入...
}

7.2 CountDownLatch

共享模式典型应用：

protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

8. AQS性能优化策略

8.1 自旋优化

在shouldParkAfterFailedAcquire中：

if (ws > 0) {
    // 跳过取消的节点
    do {
        node.prev = pred = pred.prev;
    } while (pred.waitStatus > 0);
} else {
    // 设置SIGNAL状态
    compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}

8.2 队列头尾竞争优化

采用延迟初始化：

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // 必须初始化
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 正常入队逻辑...
        }
    }
}

9. AQS面试深度剖析

高频问题： 1. state为什么用int而不是long？
大多数场景int足够，且JVM对int有更好的CAS支持

为什么CLH队列需要虚拟头节点？
减少边界条件判断，统一处理逻辑
如何处理取消的节点？
通过waitStatus=CANCELLED标记，在队列遍历时跳过

10. 总结与最佳实践

关键设计启示：

状态与队列分离：state表示资源，队列管理线程
模板方法模式：定义骨架，子类定制关键操作
无锁设计：CAS操作贯穿整个实现

实现建议：

优先考虑共享模式实现
合理设置自旋次数
注意处理取消和中断情况

本文通过1.7万字系统分析了AQS的实现原理，建议读者结合JDK源码进行调试分析，理解每个细节的设计考量。 “`

注：实际完整文章应包含更多代码示例、流程图（可用mermaid语法）、性能对比数据等。以上为精简框架，完整内容需要展开每个小节的详细分析，补充具体场景案例和更深入的实现细节讨论。