Java高级面试必问：AQS 到底是什么？-编程阁

此篇主要针对大家感兴趣的AQS详细说明，欢迎评论区指正！

一、AQS究竟是什么？

AQS（AbstractQueuedSynchronizer）不是一个具体的锁，而是一个构建锁和同步器的框架。你可以把它想象成汽车工厂的"底盘平台"：同样的底盘可以造出轿车、SUV、卡车等各种车型。

二、为什么需要AQS？解决了什么问题？

1.问题背景

在AQS出现之前，Java只有synchronized关键字实现同步，但它存在局限：

无法实现公平锁
没有超时等待机制
没有条件变量的精细控制
无法中断一个正在等待的线程

2.AQS的解决方案

AQS提供了一个通用的并发控制框架，让开发者可以：

自定义各种锁策略
实现复杂的同步需求
获得更好的性能

三、AQS的架构和工作原理

核心结构：CLH队列 + 状态变量

关键代码：AQS核心方法

public abstract class AbstractQueuedSynchronizer { private volatile int state; private transient volatile Node head; private transient volatile Node tail; static final class Node { volatile Node prev; volatile Node next; volatile Thread thread; volatile int waitStatus;

AQS 的两种同步模式

独占模式（Exclusive Mode）

特点：同一时刻仅允许一个线程持有资源。
典型应用：ReentrantLock、CountDownLatch。
核心方法：
acquire(int arg)：获取资源（失败则入队阻塞）。
release(int arg)：释放资源（唤醒后继节点）。

acquire 流程

共享模式（Shared Mode）

特点：允许多个线程同时持有资源（如读锁、信号量）。
典型应用：Semaphore、ReentrantReadWriteLock的读锁。
核心方法：
acquireShared(int arg)：获取共享资源。
releaseShared(int arg)：释放共享资源（可能唤醒多个后继）。

releaseShared 的传播性

private void doReleaseShared() { if (h != null && h != tail) { int ws = h.waitStatus; if (ws == Node.SIGNAL) { if (compareAndSetWaitStatus(h, Node.SIGNAL, 0)) unparkSuccessor(h); // 唤醒后继 else if (ws == 0) compareAndSetWaitStatus(h, 0, Node.PROPAGATE); if (h == head) break; // 若head未变则退出

四、实际开发中如何与AQS交互

场景1：使用现成的AQS实现

普通开发不需要直接使用AQS，而是使用基于AQS的工具类：

import java.util.concurrent.locks.ReentrantLock;import java.util.concurrent.CountDownLatch;import java.util.concurrent.Semaphore;public class AQSInPractice { public static void main(String[] args) throws InterruptedException { // 1. ReentrantLock - 可重入锁 ReentrantLock lock = new ReentrantLock(true); // true表示公平锁 System.out.println("锁已获取"); lock.unlock(); // 2. CountDownLatch - 线程协调 CountDownLatch latch = new CountDownLatch(3); for (int i = 0; i < 3; i++) { new Thread(() -> { latch.countDown(); latch.await(); // 等待所有线程完成 System.out.println("所有任务完成"); // 3. Semaphore - 信号量 Semaphore semaphore = new Semaphore(3); // 允许3个线程同时访问 semaphore.acquire(); semaphore.release();

场景2：扩展AQS实现自定义同步器

可以继承AQS实现自定义同步需求：

import java.util.concurrent.locks.AbstractQueuedSynchronizer;// 一个简单的"最多允许N个线程访问"的自定义锁public class SimpleLimitLock { private final Sync sync; public SimpleLimitLock(int limit) { sync = new Sync(limit); private static class Sync extends AbstractQueuedSynchronizer { Sync(int limit) { setState(limit); // 初始化状态为允许的最大线程数 protected int tryAcquireShared(int acquires) { int available = getState(); int remaining = available - acquires; // 如果剩余许可不足或CAS成功，返回结果 if (remaining < 0 || compareAndSetState(available, remaining)) { return remaining; protected boolean tryReleaseShared(int releases) { int current = getState(); int next = current + releases; if (compareAndSetState(current, next)) { return true; sync.acquireShared(1); public void unlock() { sync.releaseShared(1);

五、AQS在Java并发体系中的角色

// Java并发编程的层次结构： ┌─────────────────────────────────────────────────┐ │ Java并发应用层 │ │ • 线程池 (ExecutorService) │ │ • 并发集合 (ConcurrentHashMap) │ │ • 异步任务 (CompletableFuture) │ ├─────────────────────────────────────────────────┤ │ AQS工具类层 │ │ • ReentrantLock │ │ • Semaphore │ │ • CountDownLatch │ │ • CyclicBarrier │ ├─────────────────────────────────────────────────┤ │ AQS框架层 │ │ • 状态管理 (state) │ │ • 队列管理 (CLH队列) │ │ • 线程阻塞/唤醒 (LockSupport) │ ├─────────────────────────────────────────────────┤ │ JVM/OS层 │ │ • synchronized监视器锁 │ │ • CAS指令 (Unsafe类) │ │ • 线程调度 (操作系统) │ └─────────────────────────────────────────────────┘

六、AQS的工作流程示例

以ReentrantLock的加锁过程为例：

sync.acquire(1); // 调用AQS的模板方法 abstract static class Sync extends AbstractQueuedSynchronizer { // AQS.acquire()的调用链： // 1. tryAcquire() 尝试获取锁（子类实现） // 2. addWaiter() 创建节点加入队列 // 3. acquireQueued() 在队列中自旋/阻塞 // 4. 如果被中断过，自我中断恢复状态

具体过程可以用图表示：

七、实际开发中的最佳实践

1.选择合适的同步工具

public class SyncToolSelection { void useReentrantLock() { ReentrantLock lock = new ReentrantLock(true); // 公平锁 void useSemaphore() { Semaphore semaphore = new Semaphore(10); // 最多10个线程同时访问 // 适用于数据库连接池、限流场景 void useCountDownLatch() { CountDownLatch latch = new CountDownLatch(5); // 适用于启动阶段等待初始化完成 void useCyclicBarrier() { CyclicBarrier barrier = new CyclicBarrier(4); // 适用于并行计算，等待所有线程到达屏障

2.避免常见陷阱

public class AQSPitfalls { ReentrantLock lock = new ReentrantLock(); if (someCondition) { return; // 这里直接返回，忘记解锁！ lock.unlock(); // 必须在finally中释放 void conditionVariableMistake() { ReentrantLock lock = new ReentrantLock(); Condition condition = lock.newCondition(); // 错误：没有在lock保护下调用await // condition.await(); condition.await(); lock.unlock();