AQS 的等待队列:CLH 变体如何实现公平与非公平锁

举报
yd_254127822 发表于 2026/11/16 08:23:02 2026/11/16
【摘要】 从 AQS 的 state、Node 等待队列和 acquire/release 流程出发,拆解 CLH 变体的入队、挂起与唤醒机制,说明公平锁和非公平锁之间的核心实现机制差别,并给出一个可运行的 AQS 最小锁示例。

问题背景: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、哪些可以依赖独占所有者线程。

【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。