AQS
AbstractQueuedSynchronizer(AQS)是 Java 并发包(java.util.concurrent)的基石。
核心思想:利用一个 volatile int 变量表示同步状态,并通过一个 FIFO 双向队列(CLH 队列)来管理线程的排队与阻塞。
主要组件
1. 同步状态 (state)
作用:表示锁或同步器的状态。
原子性:通过 CAS 操作(compareAndSetState)来保证修改的原子性。
不同子类含义说明:
- 独占锁:state=0 表示未锁定,state=1 表示已锁定,state>1 表示重入次数。
- 共享锁(Semaphore):state 表示剩余的许可数量。
- 倒计时(CountDownLatch):state 表示计数器的值。
2. CLH 同步队列
这是一个 FIFO(先进先出)的双向链表,用于存放获取同步状态失败的线程。
组成:
- 头节点(head):代表当前持有锁的线程(或刚刚释放锁的线程)。
- 尾节点(tail):指向队列的最后一个节点。
- Node 节点:队列中的每个元素都是一个 Node,封装了等待的线程(Thread)、节点状态(waitStatus)以及前后指针(prev, next)。
3. 模板方法模式
AQS 定义了顶层的算法骨架(如 acquire、release),而将具体的业务逻辑(如何获取/释放)留给了子类通过重写钩子方法来实现。
模板方法 (final):acquire(), release();定义通用流程(排队、阻塞、唤醒)。开发者不重写,直接调用。
钩子方法 (protected):tryAcquire(), tryRelease();必须由子类实现。定义 state 的修改规则。
原理
独占模式
获取锁流程:acquire(int arg)
当线程调用 lock() 方法时,最终会执行到 AQS 的 acquire 模板方法:
// AbstractQueuedSynchronizer.java
public final void acquire(int arg) {
// 1. 先尝试获取锁 (调用子类实现的 tryAcquire)
// 2. 如果获取失败,则入队并阻塞
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
下面以ReentrantLock说明内部调用的方法流程:
1. tryAcquire(arg):尝试获取锁
AQS 本身不实现该方法,由子类(如 NonfairSync)实现。在非公平锁中,它会直接尝试用 CAS 修改 state 从 0 到 1。如果成功,表示获取锁成功,线程直接返回,继续执行业务代码。如果失败(返回 false),进入下一步。
// NonfairSync.java
// AQS 本身不实现该方法,由子类(如 `NonfairSync`)实现。
// 在非公平锁中,它会直接尝试用 CAS 修改 `state` 从 0 到 1。如果成功,表示获取锁成功,线程直接返回,继续执行业务代码。如果失败(返回 false),进入下一步。
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
// Sync.java
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState(); // 获取当前同步状态
// 情况1:锁未被占用 (state == 0)
if (c == 0) {
// 直接尝试 CAS 抢占,不考虑队列中是否有等待者(非公平性体现)
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current); // 设置锁持有线程
return true;
}
}
// 情况2:锁已被占用,但持有者是当前线程(可重入)
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // 溢出检查
throw new Error("Maximum lock count exceeded");
setState(nextc); // 更新重入次数
return true;
}
// 抢占失败或不是重入,返回 false
return false;
}
如果是公平锁(FairSync),tryAcquire 会先检查队列中是否有等待的线程(hasQueuedPredecessors()),如果有则直接返回 false,保证先来先得
2. addWaiter(Node mode):将线程加入等待队列
将当前线程构造成一个独占模式的 Node 节点,并尝试快速入队(CAS 设置尾节点)。
- 如果尾节点存在,直接尝试插入(CAS)。
- 如果尾节点不存在(队列未初始化)或 CAS 失败,则进入 enq(node) 方法进行自旋入队(死循环直到入队成功)。
private Node addWaiter(Node mode) {
// 1. 将当前线程包装成 Node 节点 (mode 为 Node.EXCLUSIVE 独占模式)
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail;
// 2. 快速路径:如果尾节点存在,尝试直接通过 CAS 插入队尾
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 3. 慢速路径:如果尾节点为空(队列未初始化)或 CAS 失败,进入自旋入队
enq(node);
return node;
}
// 自旋入队(保证入队成功)
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // 如果队列为空,先初始化头节点
if (compareAndSetHead(new Node()))
tail = head;
} else { // 尾插法
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
acquireQueued(final Node node, int arg):在队列中自旋获取锁
这是一个自旋过程。线程入队后,会进入这个方法检查是否可以阻塞。
关键逻辑:只有当当前节点的前驱节点是头节点(head)时,才会再次尝试获取锁(这是为了防止“信号丢失”)。如果前驱不是头节点,或者尝试获取锁失败,则调用 shouldParkAfterFailedAcquire 检查前驱节点的 waitStatus。如果状态允许,最终调用 LockSupport.park(this) 挂起当前线程。
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) { // 自旋
final Node p = node.predecessor(); // 获取前驱节点
// 1. 只有当前驱节点是头节点时,才允许尝试获取锁 (FIFO 原则)
if (p == head && tryAcquire(arg)) {
setHead(node); // 获取成功,将当前节点设为头节点
p.next = null; // 帮助 GC (断开旧头节点的引用)
failed = false;
return interrupted; // 返回中断状态
}
// 2. 如果获取失败,检查是否可以安全地挂起线程
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt()) // 挂起线程,并检查中断
interrupted = true; // 仅记录中断,不立即响应
}
} finally {
if (failed)
cancelAcquire(node); // 如果被取消,从队列中移除
}
}
释放锁流程:release(int arg)
线程调用unlock方法时,最终会执行到 AQS 的 release方法。
// AbstractQueuedSynchronizer.java
public final boolean release(int arg) {
// 1. 尝试释放锁 (调用子类实现的 tryRelease)
if (tryRelease(arg)) {
Node h = head;
// 2. 如果头节点不为空且状态不是初始状态,唤醒后继节点
if (h != null && h.waitStatus != 0) unparkSuccessor(h);
return true;
}
return false;
}
源码执行步骤:
**1、tryRelease(arg):**由子类实现,通常是将 state 减 1(如果是重入锁则减重入次数),当 state 变为 0 时,清空独占线程,返回 true。
**2、unparkSuccessor(h):**唤醒头节点的下一个有效节点。 它会从尾节点向前遍历(for (t = tail; t != null && t != node; t = t.prev)),找到离头节点最近的一个需要唤醒的线程(waitStatus < 0),然后调用 LockSupport.unpark(s.thread)。
共享模式
共享模式(如 Semaphore、CountDownLatch)允许多个线程同时访问资源。
获取资源:acquireShared(int arg)
// AbstractQueuedSynchronizer.java
public final void acquireShared(int arg) {
// tryAcquireShared 返回负数表示失败,0 表示成功但无剩余资源,正数表示成功且有剩余
if (tryAcquireShared(arg) < 0) doAcquireShared(arg);
}
tryAcquireShared方法会检查当前可用许可数是否充足,如果充足则通过 CAS 原子操作扣减许可,并返回剩余许可数;否则返回负数表示失败。AbstractQueuedSynchronizer类中无实现代码,需要子类实现,我们以Semaphore的实现说明其原理:
公平模式(FairSync)
protected int tryAcquireShared(int acquires) {
for (;;) { // 自旋
// 1. 先检查队列中是否有等待时间更长的线程
if (hasQueuedPredecessors()) return –1; // 如果有,当前线程直接失败,避免“插队”,保证公平性
// 2. 获取当前可用的许可数量
int available = getState();
// 3. 计算获取 acquires 个许可后,剩余的许可数量
int remaining = available – acquires;
// 4. 如果剩余许可 < 0,说明资源不足,返回负数
// 如果资源充足,则尝试通过 CAS 更新 state 状态
if (remaining < 0 || compareAndSetState(available, remaining)) return remaining; // 返回剩余许可数 (可能为负或非负)
}
}
非公平模式(FairSync)
// NonfairSync 中的实现
protected int tryAcquireShared(int acquires) {
// 直接调用非公平获取逻辑
return nonfairTryAcquireShared(acquires);
}
// Sync 类中的 final 方法
final int nonfairTryAcquireShared(int acquires) {
for (;;) { // 自旋
// 1. 获取当前可用的许可数量
int available = getState();
// 2. 计算获取后的剩余许可
int remaining = available – acquires;
// 3. 如果剩余 < 0,返回负数表示失败
// 如果剩余 >= 0,则尝试通过 CAS 更新状态
if (remaining < 0 || compareAndSetState(available, remaining))
return remaining;
// 注意:这里没有检查队列中是否有等待线程
}
}
tryAcquireShared如果返回负数,后续会执行doAcquireShared方法,该方法将线程放入队列并挂起,直到获取成功。
// 在 AbstractQueuedSynchronizer.java 中
private void doAcquireShared(int arg) {
// 1. 将当前线程包装成一个 "共享模式" 的节点,加入到同步队列的尾部
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
// 2. 自旋(死循环),直到获取到资源
for (;;) {
// 3. 获取当前节点的前驱节点
final Node p = node.predecessor();
// 4. 关键判断:如果前驱节点是头节点(head),说明当前线程排在队列最前面,有资格尝试抢资源
if (p == head) {
// 5. 再次尝试获取资源
int r = tryAcquireShared(arg);
if (r >= 0) {
// 6. 获取成功 (r >= 0 说明成功且可能有剩余) 设置当前节点为头节点,并且“传播”唤醒后续节点
setHeadAndPropagate(node, r);
p.next = null; // help GC (断开旧头节点的引用)
if (interrupted) selfInterrupt();
failed = false;
return;
}
}
// 7. 如果前驱不是头节点,或者尝试获取失败 检查是否需要阻塞 (会设置前驱节点的状态为 SIGNAL)
if (shouldParkAfterFailedAcquire(p, node) &&
// 8. 真正阻塞线程的地方
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed) cancelAcquire(node); // 异常处理:取消获取,将节点移出队列
}
}
释放资源:releaseShared(int arg)
// AbstractQueuedSynchronizer.java
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
// 唤醒所有等待的共享节点
doReleaseShared();
return true;
}
return false;
}
下面以Semaphore为例来说明tryReleaseShared和doReleaseShared方法:
// 在 Semaphore 的内部类 Sync 中实现,尝试释放共享资源即增加state的值
protected final boolean tryReleaseShared(int releases) {
for (;;) { // 自旋(死循环),保证 CAS 操作的线程安全
// 1. 获取当前的 state 值(当前可用许可数)
int current = getState();
// 2. 计算释放后的许可数(通常是 +1)
int next = current + releases;
// 3. 防止整数溢出(如果 next 变成了负数,说明许可数达到了最大值)
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
// 4. 通过 CAS 原子操作尝试更新 state 值
if (compareAndSetState(current, next))
return true; // 更新成功,返回 true,表示释放成功
// 如果 CAS 失败(说明 state 被其他线程修改了),则继续循环重试
}
}
// 在 AbstractQueuedSynchronizer.java 中,执行释放(唤醒后继)
private void doReleaseShared() {
for (;;) { // 自旋
Node h = head;
// 1. 检查队列是否为空,以及队列中是否至少有一个等待线程 (head != tail)
if (h != null && h != tail) {
int ws = h.waitStatus;
// 2. 如果头节点的状态是 SIGNAL,说明它期待被唤醒后继节点
if (ws == Node.SIGNAL) {
// 尝试将头节点的状态从 SIGNAL (等待唤醒) 改为 0
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // 如果 CAS 失败,重试自旋
// 3. 唤醒头节点的后继节点
unparkSuccessor(h);
}
// 4. 如果头节点状态为 0,尝试将其改为 PROPAGATE (共享模式特有)
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // 如果 CAS 失败,重试自旋
}
// 5. 如果头节点没有发生变化,说明唤醒操作已完成或无需唤醒,退出自旋
if (h == head)
break;
}
}
Node 节点状态详解 (waitStatus)
Node 的 waitStatus 字段决定了线程的排队行为
| SIGNAL | -1 | 核心状态。当前节点的后继节点已经被(或将要被)挂起,因此当前节点在释放锁或取消时,必须唤醒其后继节点。 |
| CANCELLED | 1 | 线程已取消(超时或中断)。该节点失效,将被 AQS 清理。 |
| CONDITION | -2 | 节点在条件队列(Condition Queue)中,不在同步队列中。 |
| PROPAGATE | -3 | 仅在共享模式下使用,表示释放共享资源的操作应传播给后续节点。 |
| INITIAL | 0 | 新创建的节点处于这种状态。 |
总结
AQS 通过 CAS 修改 state 来竞争资源,竞争失败的线程通过自旋 + CAS 入队,并利用 LockSupport 挂起自己,等待前驱节点在释放时唤醒。
子类说明
ReentrantLock (可重入锁)
作用
提供比 synchronized 更强大的锁机制。支持公平锁/非公平锁、可中断等待、超时获取锁等特性。
使用示例
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
private int count = 0;
private final ReentrantLock lock = new ReentrantLock();
public void increment() {
lock.lock(); // 获取锁
try {
count++;
} finally {
lock.unlock(); // 必须在 finally 中释放
}
}
}
原理
- 内部通过继承 AQS 实现。state 变量表示锁的持有计数。
- 如果 state=0,表示锁空闲,线程可以通过 CAS 操作将其置为 1 来获取锁。
- 如果当前线程已经持有锁,则 state 递增(重入),释放时递减,直到为 0 才真正释放。
注意事项
- 必须手动释放:必须在 finally 块中调用 unlock(),否则一旦临界区代码抛出异常,锁将永远无法释放,导致死锁。
- 避免死锁:尽量使用 tryLock(timeout) 来避免无限期等待。
Condition (条件变量)
作用
用于实现线程间的等待/通知机制(类似 Object.wait() 和 Object.notify()),但比传统的 wait/notify 更灵活,一个 Lock 可以创建多个 Condition,实现精准唤醒。
使用示例
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class BoundedBuffer {
final ReentrantLock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
// 生产者等待 notFull,消费者等待 notEmpty
}
原理
ConditionObject 是 AQS 的内部类。它维护了一个等待队列,调用 await() 的线程会释放锁并进入该队列等待,直到其他线程调用 signal() 将其移回 AQS 的同步队列中。
注意事项
必须先获取锁,才能调用 await() 或 signal()。
ReentrantReadWriteLock (可重入读写锁)
作用
解决“读多写少”的并发场景。读锁是共享的,写锁是独占的。
使用示例
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Cache {
private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
private Object data;
// 读操作
public Object read() {
rwLock.readLock().lock();
try {
return data;
} finally {
rwLock.readLock().unlock();
}
}
// 写操作
public void write(Object newData) {
rwLock.writeLock().lock();
try {
data = newData;
} finally {
rwLock.writeLock().unlock();
}
}
}
原理
AQS 的 state 状态值被拆分为高 16 位(读锁状态)和低 16 位(写锁状态)。
- 读锁:共享模式。如果写锁未被占用,读线程可以获取锁(高 16 位加 1)。
- 写锁:独占模式。只有在读锁和写锁都空闲时才能获取。
注意事项
写锁可以降级为读锁(先写后读),但读锁不能升级为写锁(容易导致死锁)。
Semaphore (信号量)
作用
控制同时访问特定资源的线程数量(限流/流量控制),相当于一个“许可证”池。
使用示例
import java.util.concurrent.Semaphore;
public class SemaphoreExample {
// 允许最多 3 个线程同时访问
private static final Semaphore SEMAPHORE = new Semaphore(3);
public void doWork() throws InterruptedException {
SEMAPHORE.acquire(); // 获取许可
try {
System.out.println(Thread.currentThread().getName() + " 正在工作…");
Thread.sleep(2000); // 模拟工作
} finally {
SEMAPHORE.release(); // 释放许可
}
}
}
原理
基于 AQS 的共享模式。state 表示当前可用的许可证数量。
- acquire():尝试获取许可,如果 state > 0,则 state 减 1;否则线程进入等待队列。
- release():释放许可,state 加 1,并唤醒等待队列中的线程。
注意事项
常用于数据库连接池、限流器(RateLimiter)的底层实现。
CountDownLatch (倒计时门闩)
作用
让一个或多个线程等待,直到其他线程完成一系列操作。计数器一旦归零,无法重置(一次性)。
使用示例
import java.util.concurrent.CountDownLatch;
public class StartRace {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(3); // 3 个任务
for (int i = 0; i < 3; i++) {
new Thread(() -> {
System.out.println("任务完成");
latch.countDown(); // 计数减 1
}).start();
}
latch.await(); // 主线程等待,直到计数为 0
System.out.println("所有任务完成,继续执行");
}
}
原理
基于 AQS 的共享模式。state 初始化为计数值。
- 调用 await() 的线程会检查 state,如果不为 0 则阻塞。
- 调用 countDown() 会将 state 减 1,当 state 变为 0 时,唤醒所有等待线程。
注意事项
不可重用。如果需要循环使用的屏障,请使用 CyclicBarrier。
CyclicBarrier (循环栅栏)
作用
让一组线程互相等待,直到到达一个公共的屏障点(Barrier Point)。它可以被重置和重复使用。
使用示例
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierExample {
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
System.out.println("所有线程已到达,开始下一阶段");
});
for (int i = 0; i < 3; i++) {
new Thread(() -> {
System.out.println("线程到达");
try {
barrier.await(); // 等待其他线程
} catch (Exception e) {}
}).start();
}
}
}
原理
内部使用 ReentrantLock 和 Condition 实现。每个线程调用 await() 时计数器减 1,当计数器为 0 时,触发 Runnable 任务(如果有的话),然后调用 signalAll() 唤醒所有等待线程,并重置计数器。
注意事项
与 CountDownLatch 相反,它是“减到 0 就放行并重置”,而 CountDownLatch 是“减到 0 就结束”。
FutureTask (异步任务)
作用
代表一个可取消的异步计算任务。可以获取任务执行结果(get() 会阻塞),或取消任务。
使用示例
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class FutureTaskExample {
public static void main(String[] args) throws Exception {
Callable<Integer> task = () -> {
Thread.sleep(1000);
return 42;
};
FutureTask<Integer> futureTask = new FutureTask<>(task);
new Thread(futureTask).start();
System.out.println("结果: " + futureTask.get()); // 阻塞直到结果可用
}
}
原理
基于 AQS 的独占模式。state 表示任务的生命周期(NEW, COMPLETING, NORMAL, CANCELLED 等)。调用 get() 时,如果任务未完成(state 不是 NORMAL),线程会进入 AQS 队列等待。
注意事项
任务一旦完成或取消,就不能重新启动。


