当前位置：首页 > news >正文

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

news 2026/5/27 5:40:26

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

【免费下载链接】JavaGuideJava 面试 & 后端通用面试指南，覆盖计算机基础、数据库、分布式、高并发、系统设计与 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; } }