结论先行:AQS(AbstractQueuedSynchronizer)是 juc 包半壁江山的底层框架,核心只有三样东西:一个 volatile int state 表达同步资源、一个 CLH 变体的双向等待队列、一组由子类实现的模板方法。ReentrantLock、Semaphore、CountDownLatch 全是「换个 state 语义」的实现,理解一个等于理解一批。

state:一个字段的多种语义

AQS 把「同步状态」抽象成 int,语义由子类定义。在 ReentrantLock 里 state 为 0 表示无锁、大于 0 表示持有线程的重入次数;在 Semaphore 里是剩余许可数;在 CountDownLatch 里是剩余计数。修改 state 用 CAS 保证原子性(节选自非公平锁的 tryAcquire,简化):

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();                        // volatile 读
    if (c == 0) {
        if (compareAndSetState(0, acquires)) { // CAS 抢锁
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;              // 重入:判断 owner 后直接累加
        setState(nextc);
        return true;
    }
    return false;
}

持有线程内的重入不需要 CAS(只有自己会改 state),判断 owner 后直接累加,这就是可重入的全部实现。这种「框架管队列与阻塞、子类只回答 state 增减算不算获取成功」的分工,是 AQS 最值得学习的设计:acquire/release 模板方法固定流程骨架,tryAcquire/tryRelease 留给子类填语义。常见同步器的 state 对照:

同步器state 的语义释放条件典型场景
ReentrantLock0 无锁,>0 重入次数减到 0 并清 owner互斥访问共享资源
Semaphore剩余许可数归还许可限流、资源池
CountDownLatch剩余计数计数减到 0 放行 await等一组并行任务完成
ReentrantReadWriteLock高 16 位读、低 16 位写读写各自清零读多写少的缓存

AQS 还有独占与共享两种模式:独占模式一次只有一个线程持有(上面的 tryAcquire),共享模式允许多个线程同时通过(tryAcquireShared 返回剩余量,负数失败、零临界、正数有余量)。Semaphore 与 CountDownLatch 的门闩语义都靠共享模式实现,释放时用 setHeadAndPropagate 把「唤醒」沿队列传播下去——CountDownLatch 计数归零唤醒所有等待者,就是这个传播机制在起作用。

还有一段值得知道的演进:JDK 9 对 AQS 做过一次纯架构重构,把 state、owner、等待队列各自封装成独立的原子对象,代码可读性大幅提升,对外行为完全兼容。读源码时如果发现版本间内部结构差异巨大,不是语义变了,而是这次整理——结论和排查方法跨版本通用。

抢不到锁怎么办:入队 + 挂起

acquire 的骨架是四步:tryAcquire 失败 → addWaiter 把当前线程包装成 Node 追加到队列尾部 → acquireQueued 自旋:只有前驱是 head 才有资格再试一次 tryAcquire,否则调用 LockSupport.park() 挂起自己 → 被唤醒后继续循环。release 则是 tryRelease 把 state 减到 0 后 unpark 队头的下一个节点。「自旋一次 + park」的设计兼顾了响应速度和 CPU 占用,避免了纯自旋的空转。还有一个实现细节:入队时如果发现前驱节点被取消(waitStatus 为 CANCELLED),会先向前清理失效节点再挂起,队列里的取消节点靠这个机制惰性摘除——jstack 里偶尔看到的「队列里挂着已死线程」多数是还没轮到清理,不代表泄漏。

队列结构本身也值得看一眼:双向链表,head 是不存线程的哨兵节点,每个 Node 记录等待状态与线程引用。节点入队用 CAS 追加尾部,出队由前驱把 waitStatus 置为 SIGNAL 后 unpark 后继完成。这套结构把「唤醒责任」明确交给持有锁的线程,被唤醒方不需要竞争谁负责叫醒它,简单且不会漏唤。

公平与非公平:一行判断的差别

非公平锁的 lock() 上来就直接 CAS 抢 state,抢不到才入队——插队是默认行为,吞吐更高,因为减少了线程挂起和唤醒的开销。公平锁在 tryAcquire 里多一步判断:

public final boolean hasQueuedPredecessors() {
    Node t = tail; Node h = head; Node s;
    // 队列非空且队头后面还有别人的线程在排 → 不许插队
    return h != t &&
           ((s = h.next) == null || s.thread != Thread.currentThread());
}

队列里还有排在前面的线程就不抢,乖乖排队。业务上除非明确要求 FIFO 语义(如排队顺序影响计费),默认用非公平锁即可。

性能差异的另一面也要说清:非公平的「插队」在极端竞争下可能让某些线程长期抢不上锁。监控上「队列长度高但吞吐正常」就是这种形态的信号——优先方案是缩短临界区、减少持锁时间,把锁换成公平锁只是最后的手段。

Condition:ReentrantLock 独有的能力

synchronized 配 wait/notify 只有一条等待队列;ReentrantLock 可以创建多个 Condition,实现多组等待分别唤醒。典型例子是 ArrayBlockingQueue 内部的 notFull、notEmpty 两个条件——生产者只在队列满时等 notFull,消费者取走元素后精准 signal 它,不会误唤醒无关线程。notifyAll 的问题是「唤醒所有等待者再自己竞争」,等待者越多浪费越大;多个 Condition 把「等同一个条件的线程」分在一组,signal 只动一组。这是显式锁在功能上真正超出 synchronized 的地方,值得在选型时认真评估而不只是当备胎。

实现上每个 Condition 持有一条单向条件队列:await 先把当前线程包装成节点挂进条件队列并释放锁,signal 时把节点从条件队列摘下、转移到 AQS 同步队列尾部排队拿锁。所以 await 返回时线程必然已重新持有锁——这正是它与 Object.wait 语义一致的地方,也是「signal 之后不会立刻执行、还要排队拿锁」这个细节的来源。理解两条队列的分工后,ArrayBlockingQueue、ThreadPoolExecutor 工作队列的源码都能直接读懂。

tryLock:工程上最常用的高级能力

排查死锁要会用工具是基本功,但日常业务里 tryLock 的价值更直接:给加锁加超时,锁竞争激烈时快速失败或降级,避免线程无限堆积:

// 错误写法:lock() 无限期等待,锁竞争激烈时线程无上限堆积
lock.lock();
try {
    return queryRemote(orderId);   // 下游一慢,临界区变长,
                                   // 排队线程数随之失控
} finally {
    lock.unlock();
}

// 正确写法:tryLock 带超时,拿不到锁走降级,把失败控制在预算内
boolean locked = false;
try {
    locked = lock.tryLock(200, TimeUnit.MILLISECONDS);
    if (!locked) {
        return cachedValue(orderId);          // 降级:读缓存或返回默认值
    }
    return queryRemote(orderId);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();       // 恢复中断标记
    return cachedValue(orderId);
} finally {
    if (locked) {
        lock.unlock();
    }
}

tryLock 还有一个隐藏收益:拿锁的超时预算 + 降级路径天然构成对下游故障的隔离,比「等锁 + 等下游」两级无限等待的组合健壮得多。

最后补一句 juc 家族的关系图:AQS 在底层管队列与阻塞,ReentrantLock/Semaphore/CountDownLatch 在上层提供语义,BlockingQueue 的不少实现内部再组合它们。排查这类组件的问题时,看懂 state 和队列,等于拿到了半张地图。

生产案例

某次线上线程池耗尽告警,jstack 抓到一组标准死锁现场:线程 A 持有订单锁等库存锁,线程 B 持有库存锁等订单锁——两段代码分属不同迭代版本,各自新增了对另一把锁的获取,锁获取顺序从此不一致。接入的 ThreadMXBean.findDeadlockedThreads() 定时检测在死锁形成后第一时间触发了通知,避免了业务无限挂起。修复分两层:短期统一所有多锁场景的获取顺序(对锁对象做全局排序,按订单号、库存 ID 的固定先后);长期把 tryLock 超时作为多锁场景的编码规范写进评审清单。这个案例的延伸结论是:AQS 的等待队列让「谁在等谁」在 jstack 里清晰可见,死锁本身不可怕,可怕的是没有检测手段、靠用户投诉才发现。复盘之后把「锁获取顺序」写进了架构文档,新代码评审对照检查,比事故后再补规范有效得多。检测工具兜底加规范前置,两层防御足够把死锁从「线上事故」降级为「监控事件」。