深入理解Java AQS：抽象队列同步器的核心原理与实战指南-CSDN博客

深入理解Java AQS：抽象队列同步器的核心原理与实战指南

【免费下载链接】JavaGuide Java 面试 & 后端通用面试指南，覆盖计算机基础、数据库、分布式、高并发、系统设计与 AI 应用开发项目地址: https://gitcode.com/gh_mirrors/ja/JavaGuide

AQS（AbstractQueuedSynchronizer）是Java并发编程中最重要的基础组件之一，它为构建各种同步器提供了强大的底层框架支持。本文将深入解析AQS的核心原理，帮助你掌握这一Java并发编程的关键技术。😊

🔍 AQS是什么？

AQS全称为AbstractQueuedSynchronizer，翻译过来就是抽象队列同步器。这个位于java.util.concurrent.locks包下的抽象类，为构建锁和同步器提供了通用框架实现。

AQS的核心思想是：如果请求的共享资源空闲，则将当前请求资源的线程设置为有效工作线程，并将共享资源设置为锁定状态；如果共享资源被占用，则需要一套线程阻塞等待以及被唤醒时锁分配的机制。AQS正是基于CLH锁队列的变体来实现这一机制的。

🎯 AQS的核心设计原理

1. 状态管理与CLH队列

AQS使用一个volatile int state变量来表示同步状态，通过内置的FIFO线程等待队列（CLH变体队列）来完成获取资源线程的排队工作。

状态变量state：

// 共享变量，使用volatile修饰保证线程可见性
private volatile int state;

AQS提供了三个protected final方法来操作状态：

getState()：返回同步状态的当前值
setState(int newState)：设置同步状态的值
compareAndSetState(int expect, int update)：原子地（CAS操作）将同步状态值设置为给定值

2. 资源共享的两种模式

AQS定义了两种资源共享模式：

独占模式（Exclusive）：只有一个线程能执行，如ReentrantLock

需要实现tryAcquire()和tryRelease()方法
典型应用：互斥锁

共享模式（Share）：多个线程可同时执行，如Semaphore、CountDownLatch

需要实现tryAcquireShared()和tryReleaseShared()方法
典型应用：信号量、倒计时器

图：线程池中的任务队列机制，类似于AQS的等待队列

🏗️ AQS的内部结构

1. Node节点结构

AQS将每条请求共享资源的线程封装成一个Node节点来实现锁的分配：

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)：节点在等待Condition
PROPAGATE(-3)：用于共享模式传播
0：新节点加入队列时的初始状态

2. CLH变体队列

AQS使用的等待队列是CLH锁队列的变体，它是一个双向队列。与原始的CLH锁队列相比，主要优化有两点：

由自旋优化为自旋+阻塞：减少CPU资源浪费
由单向队列优化为双向队列：简化队列操作，提高唤醒效率

🔧 AQS的工作流程

1. 独占模式获取资源

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

获取资源的流程：

尝试通过tryAcquire()获取资源
如果失败，将线程封装为Node节点加入等待队列
在队列中阻塞等待，直到被唤醒后再次尝试获取资源

2. 独占模式释放资源

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

释放资源的流程：

尝试通过tryRelease()释放资源
如果成功释放，唤醒等待队列中的后继节点

3. 共享模式获取资源

共享模式允许多个线程同时获取资源，这在信号量（Semaphore）和倒计时器（CountDownLatch）中非常有用：

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

💡 如何基于AQS实现自定义同步器

基于AQS实现自定义同步器非常简单，只需要继承AbstractQueuedSynchronizer并重写以下模板方法：

// 独占方式：尝试获取资源
protected boolean tryAcquire(int arg)

// 独占方式：尝试释放资源  
protected boolean tryRelease(int arg)

// 共享方式：尝试获取资源
protected int tryAcquireShared(int arg)

// 共享方式：尝试释放资源
protected boolean tryReleaseShared(int arg)

// 该线程是否正在独占资源
protected boolean isHeldExclusively()

实现步骤：

定义同步器类，继承AbstractQueuedSynchronizer
根据需求选择实现独占模式或共享模式的方法
在tryAcquire()/tryRelease()中定义资源获取和释放的逻辑

🚀 AQS在实际框架中的应用

1. ReentrantLock的实现

ReentrantLock是AQS最典型的应用之一。它的内部类Sync继承自AQS，实现了可重入锁的核心逻辑：

// 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;
}

2. Semaphore的实现

Semaphore使用AQS的共享模式来实现信号量机制：

// Semaphore中的非公平尝试获取共享资源
final int nonfairTryAcquireShared(int acquires) {
    for (;;) {
        int available = getState();  // 可用资源数量
        int remaining = available - acquires;  // 剩余资源数量
        if (remaining < 0 || compareAndSetState(available, remaining))
            return remaining;
    }
}

📊 AQS性能优势分析

AQS之所以性能优秀，主要得益于以下几个设计：

CAS操作：大量使用CAS操作来保证并发安全
自旋+阻塞混合机制：减少不必要的线程切换
双向链表队列：提高节点操作的效率
状态机设计：通过waitStatus状态管理节点生命周期

🎯 总结与最佳实践

AQS作为Java并发框架的基石，理解其原理对于深入掌握Java并发编程至关重要：

核心要点：

AQS通过state变量管理同步状态
使用CLH变体队列管理等待线程
提供独占和共享两种资源共享模式
基于模板方法模式，便于扩展

最佳实践：

优先使用现有的AQS实现类（如ReentrantLock、Semaphore）
在需要自定义同步器时，继承AQS并重写相应方法
理解不同同步器的state语义差异
注意线程中断的处理机制

通过深入理解AQS，你不仅能更好地使用Java并发工具类，还能设计出更高效的并发组件。AQS的设计思想也体现了Java并发框架的精髓：分离关注点，提供通用框架，支持灵活扩展。

图：理解线程池参数关系有助于掌握AQS的资源管理机制

进一步学习：

阅读docs/java/concurrent/aqs.md深入了解AQS源码
查看docs/java/concurrent/reentrantlock.md学习AQS在实际锁中的应用
实践基于AQS实现自定义同步器，加深理解

掌握AQS，你就掌握了Java并发编程的核心钥匙！🔑

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考