AQS AbstractQueuedSynchronizer的同步框架是什么

发布时间：2021-10-19 20:35:15 作者：柒染
来源：亿速云阅读：149

# AQS (AbstractQueuedSynchronizer) 的同步框架是什么

## 目录
1. [引言](#引言)  
2. [AQS 核心设计思想](#AQS-核心设计思想)  
   2.1 [同步状态管理](#同步状态管理)  
   2.2 [CLH队列变体](#CLH队列变体)  
   2.3 [模板方法模式](#模板方法模式)  
3. [AQS 核心源码解析](#AQS-核心源码解析)  
   3.1 [同步状态（state）](#同步状态state)  
   3.2 [Node节点结构](#Node节点结构)  
   3.3 [独占模式源码](#独占模式源码)  
   3.4 [共享模式源码](#共享模式源码)  
4. [AQS 在JUC中的应用](#AQS-在JUC中的应用)  
   4.1 [ReentrantLock](#ReentrantLock)  
   4.2 [CountDownLatch](#CountDownLatch)  
   4.3 [Semaphore](#Semaphore)  
5. [AQS 高级特性](#AQS-高级特性)  
   5.1 [条件变量（Condition）](#条件变量Condition)  
   5.2 [中断处理机制](#中断处理机制)  
   5.3 [超时控制](#超时控制)  
6. [AQS 性能优化](#AQS-性能优化)  
   6.1 [自旋优化](#自旋优化)  
   6.2 [队列头尾竞争优化](#队列头尾竞争优化)  
7. [AQS 的局限性](#AQS-的局限性)  
8. [总结与展望](#总结与展望)  

---

## 引言
AbstractQueuedSynchronizer（AQS）是Java并发包（JUC）的核心框架，自JDK 1.5引入以来，已成为构建锁和同步器的基石。Doug Lea通过AQS将复杂的同步逻辑抽象为统一的队列模型，实现了**同步状态管理、线程排队、阻塞/唤醒机制**的标准化。据统计，超过80%的JUC同步工具（如ReentrantLock、Semaphore等）均基于AQS实现。

---

## AQS 核心设计思想

### 同步状态管理
```java
// 关键字段：volatile保证可见性
private volatile int state;

protected final int getState() {
    return state;
}

protected final void setState(int newState) {
    state = newState;
}

// CAS原子操作
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

state是同步核心，通过CAS实现无锁更新
子类通过重写tryAcquire/tryRelease定义状态获取/释放逻辑

CLH队列变体

static final class Node {
    volatile int waitStatus;
    volatile Node prev;
    volatile Node next;
    volatile Thread thread;
    Node nextWaiter; // 用于条件队列
}

FIFO双向队列存储阻塞线程
通过waitStatus（CANCELLED/SIGNAL/CONDITION/PROPAGATE）实现精细控制

模板方法模式

// 子类需实现的模板方法
protected boolean tryAcquire(int arg) { throw new UnsupportedOperationException(); }
protected boolean tryRelease(int arg) { throw new UnsupportedOperationException(); }

// 框架提供的核心方法
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

AQS 核心源码解析

独占模式源码

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

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; // help GC
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node))
                interrupted |= parkAndCheckInterrupt();
        }
    } catch (Throwable t) {
        cancelAcquire(node);
        throw t;
    }
}

addWaiter：将线程包装为Node并入队
acquireQueued：自旋尝试获取锁，失败后挂起

AQS 在JUC中的应用

ReentrantLock 实现

// 非公平锁实现
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            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;
}

AQS 高级特性

条件变量实现

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

    public final void await() throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        Node node = addConditionWaiter();
        int savedState = fullyRelease(node);
        // ...
        while (!isOnSyncQueue(node))
            LockSupport.park(this);
    }
}

条件队列与同步队列分离
signal()时将节点从条件队列转移到同步队列

总结与展望

AQS通过精妙的设计实现了： 1. 灵活性：支持独占/共享两种模式 2. 高效性：CLH队列+CAS减少竞争 3. 可扩展性：模板方法支持快速开发新同步器

未来可能的发展方向包括： - 与虚拟线程（Project Loom）的适配 - 针对NUMA架构的队列优化

“AQS is perhaps the most important class in the JUC package.” —— Doug Lea “`

注：本文为精简版框架，完整15,200字版本需要扩展以下内容： 1. 每个章节增加详细源码分析（如Node状态转换图） 2. 补充性能对比数据（AQS vs synchronized） 3. 添加更多应用场景分析（如ThreadPoolExecutor.Worker） 4. 深入探讨内存可见性保证机制 5. 增加故障排查案例分析（死锁诊断等）