AQS 的等待队列:CLH 变体如何实现公平与非公平锁
问题背景:AQS 要解决什么
AbstractQueuedSynchronizer(AQS)是 Java 并发包里大量同步器的基础:ReentrantLock、Semaphore、CountDownLatch、ReentrantReadWriteLock 都直接或间接依赖它。它要解决的核心问题是:当多个线程竞争一个同步状态时,失败的线程去哪里等待、怎样被挂起、释放时又该唤醒谁。
AQS 把这些公共逻辑抽了出来,只留下两个模板方法给子类实现:tryAcquire 负责“尝试获取”,tryRelease 负责“尝试释放”。同步状态是一个 volatile int state,子类可以用它表示锁的重入次数、许可数量或倒计数。获取失败的线程不会原地忙等,而是被包装成节点加入一个 FIFO 等待队列,然后通过 LockSupport.park 挂起;释放线程则从队列头部唤醒后继节点。
理解 AQS,重点不是记住某个方法名,而是理解三件事:队列如何组织、节点在什么时候挂起和唤醒、公平性检查发生在哪个位置。把这三点串起来,ReentrantLock 的公平与非公平差异就非常直观了。
队列不是标准 CLH:AQS 的变体
AQS 的等待队列常被称为“CLH 队列的变体”。标准 CLH 锁中,每个线程在自己的前驱节点上自旋,适合短临界区;AQS 则要支持可能长时间等待的线程,因此改成了带 prev/next 指针的双向链表,并用 park/unpark 代替纯自旋。
每个等待节点是一个 Node,关键字段包括:
volatile int waitStatus; // SIGNAL(-1)、CANCELLED(1)、CONDITION(-2) 等
volatile Node prev;
volatile Node next;
Thread thread;
队列有一个 head 和一个 tail。head 通常是一个已经获取到同步状态、或者正在释放的哑节点,真正排队的第一个线程是 head.next。节点入队时通过 CAS 把自己接到 tail 上:
// 简化后的入队逻辑
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
acquire 的主流程是:
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
先尝试获取;失败才入队。进入 acquireQueued 后,线程会循环检查自己是不是 head.next,如果是就再试一次 tryAcquire;成功则把自己设为新的 head。如果前驱不是头节点,或者再次获取失败,就调用 shouldParkAfterFailedAcquire 把前驱的 waitStatus 改成 SIGNAL,然后 park 自己。前驱释放时会发现 SIGNAL,进而 unpark 后继节点。
这里有一个容易忽略的细节:shouldParkAfterFailedAcquire 第一次通常只是把前驱标记为 SIGNAL,并不会立刻挂起,而是让外层循环再检查一次。这样可以在“即将阻塞”和“刚好有人释放”的竞态窗口里多给一次获取机会,减少不必要的 park。如果前驱已经取消(CANCELLED),它会向前跳过这些无效节点,保证唤醒链不会断。
公平锁与非公平锁:差别在 tryAcquire 的第一行
ReentrantLock 内部有两个同步器:FairSync 和 NonfairSync。它们的 tryAcquire 大体相同,都有“state 为 0 时 CAS 抢占”和“当前线程已持有锁时重入”两个分支,差别在于公平版本多了一个队列检查。
简化后的公平版本:
protected final boolean tryAcquire(int acquires) {
Thread current = Thread.currentThread();
if (getState() == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
} else if (current == getExclusiveOwnerThread()) {
setState(getState() + acquires);
return true;
}
return false;
}
非公平版本去掉了 !hasQueuedPredecessors():
protected final boolean tryAcquire(int acquires) {
Thread current = Thread.currentThread();
if (getState() == 0 &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
} else if (current == getExclusiveOwnerThread()) {
setState(getState() + acquires);
return true;
}
return false;
}
hasQueuedPredecessors() 的作用是判断“队列里是否已经有人排在我前面”。公平锁在 CAS 之前先看这一眼,所以新来的线程不会插队;它必须排到队尾,等前面的人依次获得锁。非公平锁则直接 CAS,成功了就拿到锁,不管队列里有没有等待者。这种“插队”(barging)能减少线程唤醒和上下文切换,吞吐量通常更高,但队列中的线程可能长期抢不到锁,理论上存在饥饿风险。
公平锁的“公平”只描述队列内的先来后到,不等于操作系统调度公平,也不保证每个线程获得完全相等的执行时间。另一个细节是:ReentrantLock.tryLock() 即使在公平模式下也使用非公平的快速获取逻辑,因为它不参与排队。需要严格公平时,应使用 lock()、lockInterruptibly() 或带超时的 tryLock(timeout, unit),而不是无参 tryLock()。
释放路径相对简单:release 调用 tryRelease,如果 state 归零且队列头节点的 waitStatus 不为 0,就调用 unparkSuccessor 唤醒后继。被唤醒的线程从 park 返回,重新进入 acquireQueued 的循环,再次尝试获取。整个过程没有“释放者直接把锁交给等待者”的动作,锁仍然要靠等待者自己 CAS 抢;unpark 只是给它一次竞争机会。
代码示例:用 AQS 写一个最小公平/非公平锁
下面的 MiniLock 只实现独占模式,省略了 Condition 和超时,但足够展示 AQS 的模板方法如何工作。把 fair 传给 Sync,就能在公平和非公平之间切换。
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
public class AqsFairnessDemo {
static final class MiniLock {
private static final class Sync extends AbstractQueuedSynchronizer {
private final boolean fair;
Sync(boolean fair) {
this.fair = fair;
}
@Override
protected boolean tryAcquire(int arg) {
Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if ((!fair || !hasQueuedPredecessors()) &&
compareAndSetState(0, arg)) {
setExclusiveOwnerThread(current);
return true;
}
} else if (current == getExclusiveOwnerThread()) {
int next = c + arg;
if (next < 0) throw new Error("Maximum lock count exceeded");
setState(next);
return true;
}
return false;
}
@Override
protected boolean tryRelease(int arg) {
if (Thread.currentThread() != getExclusiveOwnerThread()) {
throw new IllegalMonitorStateException();
}
int next = getState() - arg;
if (next == 0) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
setState(next);
return false;
}
@Override
protected boolean isHeldExclusively() {
return getExclusiveOwnerThread() == Thread.currentThread();
}
}
private final Sync sync;
MiniLock(boolean fair) {
sync = new Sync(fair);
}
void lock() {
sync.acquire(1);
}
void unlock() {
sync.release(1);
}
}
public static void main(String[] args) throws Exception {
for (boolean fair : new boolean[]{true, false}) {
MiniLock lock = new MiniLock(fair);
lock.lock(); // 主线程先占住锁,让工作线程排队
Thread[] threads = new Thread[3];
for (int i = 0; i < threads.length; i++) {
int id = i;
threads[i] = new Thread(() -> {
lock.lock();
try {
System.out.println((fair ? "fair" : "nonfair") + " T" + id);
} finally {
lock.unlock();
}
});
threads[i].start();
Thread.sleep(50); // 让线程按顺序进入队列
}
Thread.sleep(100);
lock.unlock();
for (Thread t : threads) t.join();
}
}
}
公平模式下,典型输出会按 T0、T1、T2 的顺序出现;非公平模式下,刚启动或刚被唤醒的线程可能在队列线程之前 CAS 成功,输出顺序不保证。这个例子适合观察行为,不适合作为公平性测试:线程调度本身就会影响结果,真正的公平性要靠队列状态和获取顺序的严密验证。
实践建议与踩坑
第一,unlock 必须放在 finally 中。AQS 不会替你处理异常路径,业务代码一旦在持锁期间抛异常而没有释放,后续线程会永久等待。使用 ReentrantLock 时,标准的写法是 lock(); try { ... } finally { unlock(); },不要在 try 里获取锁。
第二,公平锁不等于高性能。非公平锁允许插队,减少了唤醒开销;公平锁严格排队,上下文切换更多,吞吐量通常更低。只有在业务确实需要避免饥饿、或者获取顺序有语义要求时,才考虑公平模式。大多数场景默认的非公平锁更合适。
第三,注意可中断与超时。lock() 不响应中断,lockInterruptibly() 会抛出 InterruptedException,tryLock(timeout, unit) 可以避免无限等待。做服务治理和超时控制时,应优先使用带超时的获取方式,并确保中断标志被正确处理。
第四,Condition 的等待队列和 AQS 的同步队列不是同一个队列。调用 await() 时,线程会释放锁并进入条件队列;其他线程 signal() 后,节点才被转移到同步队列重新竞争锁。不要在 await() 前后假设锁一直持有,也不要在 signal() 后立刻认为等待线程已经拿到锁。
第五,AQS 的 state 语义由子类定义。ReentrantLock 用它表示重入次数,Semaphore 用它表示剩余许可,CountDownLatch 用它表示倒计数。自己继承 AQS 时,必须保证 tryAcquire/tryRelease 对 state 的修改是安全的,并清楚哪些操作需要 CAS、哪些可以依赖独占所有者线程。
- 点赞
- 收藏
- 关注作者
评论(0)