2025 年 5 月 15 日 · JVM 与 Java 锁实践 05

把 ReentrantLock 解释成“底层用了 CAS”,只能讲清没有竞争时的一小步。真正容易出问题的,是失败以后如何排队、等待期间怎么取消,以及 signal 之后谁能继续执行。

这篇按 JDK 21.0.5 的 ReentrantLock 与 AbstractQueuedSynchronizer 源码往下走。它与许多 JDK 8 教程中的方法名和节点状态不同,所以引用全部固定到同一提交。

先把 state 和 owner 分开

ReentrantLock 用 AQS 的 state 表示持有计数:0 表示可获取,当前线程首次成功获取后变成 1,再入会继续增加。owner 用来判断是不是同一持有者,不是再建一份竞争队列。ReentrantLock.Sync

这两类数据回答不同问题:state 管同步状态,owner 管拥有者身份。AQS 本身并不规定 state 永远等于“锁了几次”;其他同步器可以赋予它别的含义。

state、owner 与等待队列分别负责什么

业务仍然需要按成功获取次数释放,并放在 finally 中。锁获取失败、异常或中断时,不能不分情况就 unlock,否则可能把原来的错误变成 IllegalMonitorStateException。

从 lock 进来,先经过 initialTryLock

这一版 Sync.lock 的核心非常短:

1
2
if (!initialTryLock())
acquire(1);

这是真实入口的摘录。先走具体策略的快速尝试,失败后才交给 AQS 获取流程。不能把旧版本的入口代码换个年份,就认为在讲同一实现。

NonfairSync 的初次尝试会直接争取把 0 改成 1;失败后,如果 owner 正是当前线程,就增加持有计数。FairSync 的初次获取会额外考虑是否已有排队线程,后续 tryAcquire 再结合是否有前驱等待者来判断。非公平实现、公平实现

“公平”也有范围:它约束这个获取协议中的竞争策略,不保证操作系统公平调度。无超时的 tryLock() 不遵循同样的公平排队限制,这点也写在该类的文档里。需要讨论顺序时,要明确调用的是哪一个 API。

acquire 的循环,防的是一连串竞争窗口

AQS.acquire 不只是“入队后 park”。它会根据节点是否位于队首、前驱是否取消、队列是否初始化等条件,多次尝试获取、整理队列或等待。acquire 实现

快速尝试失败后,AQS 怎样组织等待

我会按四个问题读这个循环:

  1. 当前节点有没有资格再次争取锁?队首位置与尚未入队的情况需要分别处理。
  2. 失败后有没有稳定地接入队列?CAS 更新 tail 与连接前后节点不是一条不可拆分的伪代码。
  3. 准备睡眠时,如何与释放者的唤醒协作?节点先设置等待状态,再重试检查,避免把关键窗口漏掉。
  4. 超时、中断或前驱取消后,谁负责标记和清理?队列里不应该永远留下失效的障碍。

本版节点相关状态包括 WAITING=1、COND=2 与负数的 CANCELLED。它们不是 JDK 8 中那套 SIGNAL=-1、CONDITION=-2 图的换皮版本。状态声明

LockSupport 提供 park/unpark 的底层等待配合,permit 不是可以无限累加的信号量计数。被唤醒也不代表锁已经到手,循环还必须重新检查同步状态。LockSupport.java

unlock 释放的是持有计数,归零才有完全释放的含义

tryRelease 先校验当前线程是不是 owner,再递减 state。只有减到 0,才清理持有者并返回完全释放的结果。AQS 的 release 再按返回值决定是否通知后继继续竞争。tryRelease

owner 信息与 volatile state 的访问顺序也在这套协议里。读源码时,不要只圈出 CAS,漏掉 getState/setState 以及成功获取、释放所要求的内存语义。业务需要的是同一锁的正确发布与读取关系,不是“看起来都有原子指令”。

重入两次只 unlock 一次,别的线程仍然不能进入;unlock 并不等于立即把 CPU 或持有权交给指定线程。非公平竞争下,还可能有新到线程参与争取。

Condition 有自己的队列,signal 做的是转移

AQS 的同步队列用于“争取获取锁”,Condition 的条件队列用于“当前条件不满足,先放下锁等待”。一个锁可以有多个 Condition,从而表达不同的业务谓词。

在这一版 enableWait 中,等待者检查自己持有锁,把节点加入条件链表,保存当前 state,再释放相应的持有计数。doSignal 则清除条件等待相关状态,并把合适的节点 enqueue 到同步队列。等待准备、signal 转移

条件队列与同步队列的转移

所以 signal 不等于“等待线程下一行马上执行”。通知者通常还持有锁,被转移的线程要等到合适时机,再按同步队列协议重新获取锁。

更容易漏掉的是重入次数:如果 await 前持有了两次,等待协议释放与恢复的也要与这份保存状态对应。实验专门验证了这一点。

1
2
3
4
5
6
7
8
9
lock.lock();
try {
while (!ready) {
changed.await();
}
consumeReadyState();
} finally {
lock.unlock();
}

ready 必须在同一同步协议里读写,通知方先改变它再 signal。while 用于重新检查谓词;Condition 对象本身不保存“一条永远记住的业务通知”。如果协议靠一次 signal 代表“库存一定足够”,多个消费者就可能在重新竞争后看见不同状态。

中断和超时,既要离开等待,也要维护队列

普通 lock() 与 lockInterruptibly() 对中断的响应不同。前者不因为中断就按可中断方式退出获取;后者可以抛出 InterruptedException。带超时的 tryLock,则给业务一个明确的失败返回机会。

在 AQS 内部,相应路径需要取消节点并处理后继关系,不只是给线程设置一个布尔标记。前驱取消后,后续节点还要有机会继续前进。理解这些分支,才知道队列图为什么不能永远只画一条没有删除的链。

等待、中断、超时和成功获取的状态关系

我不会用 getQueueLength() 的瞬时估计值来控制业务正确性,它适合观察,不是一个可靠的并发决策条件。业务超时之后也要决定是否重试、是否有幂等约束,避免把争用变成更激烈的重试。

用实验把几个误解直接拆开

本次程序先让线程排队,再中断它;还让另一个线程以两次重入进入 Condition.await,最后测试带超时获取。

检查项 本次结果
可中断等待是否退出 true
signal 后是否进入同步队列 true
通知者仍持锁时,等待者是否已恢复执行 false
await 前后重入计数 2 → 2
超时获取未成功时是否返回 false true

实验通过队列观察和条件控制确定时机,不靠“睡 100 毫秒,猜它应该已经排队”。超时参数只是用来产生分支,不拿这段短程序做锁吞吐排名。

1
python3 lab/run.py aqs --jdk "$JVM_LAB_JDK"

源程序是 AqsLab.java,结果是原始记录。

AQS 取消、队列转移和重入恢复的真实输出

我选择 ReentrantLock,通常是确实需要可中断获取、超时获取或多个条件队列。仅仅把 synchronized 改成显式锁,不会让临界区里的慢查询自动消失。先把需求与等待协议说清楚,才知道额外的控制能力有没有用上。

本篇完整 Java 示例

下面代码与配套实验使用的源文件一致。编译参数、Agent 打包和 jcmd 采集由 lab/run.py 统一组织,入口见文末实验环境说明。

展开本篇完整 Java 示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class AqsLab {
static void until(java.util.function.BooleanSupplier condition) throws Exception {
long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(3);
while (!condition.getAsBoolean() && System.nanoTime() < deadline) Thread.sleep(1);
if (!condition.getAsBoolean()) throw new AssertionError("Timed out");
}
public static void main(String[] args) throws Exception {
ReentrantLock lock = new ReentrantLock(true);
AtomicBoolean cancelled = new AtomicBoolean();
lock.lock();
Thread thread = new Thread(() -> {
try { lock.lockInterruptibly(); try {} finally { lock.unlock(); } }
catch (InterruptedException expected) { cancelled.set(true); }
}, "interruptible-waiter");
thread.start(); until(() -> lock.hasQueuedThread(thread)); thread.interrupt(); thread.join(3000);
System.out.println("interrupted_waiter_cancelled=" + cancelled.get()); lock.unlock();
if (!cancelled.get()) throw new AssertionError();
Condition condition = lock.newCondition();
AtomicInteger before = new AtomicInteger(), after = new AtomicInteger();
AtomicBoolean resumed = new AtomicBoolean();
boolean[] ready = {false}; // 只在同一把 lock 内访问。
Thread waiter = new Thread(() -> {
lock.lock(); lock.lock();
try { before.set(lock.getHoldCount()); while (!ready[0]) condition.await(); after.set(lock.getHoldCount()); resumed.set(true); }
catch (InterruptedException error) { throw new RuntimeException(error); }
finally { lock.unlock(); lock.unlock(); }
}, "condition-waiter");
waiter.start();
until(() -> { lock.lock(); try { return lock.hasWaiters(condition); } finally { lock.unlock(); } });
lock.lock();
try {
System.out.println("condition_waiters_before_signal=" + lock.getWaitQueueLength(condition));
ready[0] = true;
condition.signal();
System.out.println("transferred_to_sync_queue=" + lock.hasQueuedThread(waiter));
System.out.println("resumed_while_signaller_holds_lock=" + resumed.get());
} finally { lock.unlock(); }
waiter.join(3000);
System.out.println("hold_count_before_await=" + before.get());
System.out.println("hold_count_after_await=" + after.get());
if (!resumed.get() || after.get()!=2) throw new AssertionError();
AtomicBoolean timedOut = new AtomicBoolean();
lock.lock();
Thread timed = new Thread(() -> {
try { if (lock.tryLock(80,TimeUnit.MILLISECONDS)) { lock.unlock(); } else timedOut.set(true); }
catch (InterruptedException error) { throw new RuntimeException(error); }
}, "timed-waiter");
timed.start(); timed.join(3000); lock.unlock();
System.out.println("timed_acquire_returned_false=" + timedOut.get());
if (!timedOut.get()) throw new AssertionError();
}
}

实验环境与运行脚本

准备完整的 Temurin 21.0.5+11 JDK,选择与系统架构相符的包,并按同名 .sha256.txt 校验。需要包括 java、javac、jar、jcmd、jfr;这里固定版本是为了对应本文源码与实验结果。

将前面的 Java 示例保存为 lab/AqsLab.java,把下面脚本保存为 lab/run.py。在自己的实验项目根目录执行:

1
2
3
4
export JVM_LAB_JDK=/你的路径/jdk-21.0.5+11
# macOS JDK 包通常需追加 /Contents/Home。
"$JVM_LAB_JDK/bin/java" -version
python3 lab/run.py aqs --jdk "$JVM_LAB_JDK"

Python 脚本无第三方依赖,只编译本篇 Java 示例,输出到本项目的 assets/05-aqs/。诊断采集仅针对脚本自己启动的实验 JVM;运行结束会退出该进程。

展开本篇独立运行脚本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from pathlib import Path
import argparse,datetime,hashlib,json,os,platform,re,subprocess,time

ROOT=Path(__file__).resolve().parents[1]

def execute(args,timeout=25):
result=subprocess.run([str(x) for x in args],text=True,capture_output=True,timeout=timeout)
if result.returncode:raise RuntimeError(result.stderr[-2500:]+result.stdout[-2000:])
return result.stdout+result.stderr

def pairs(text):
return dict(line.split('=',1) for line in text.splitlines() if re.match(r'^[A-Za-z0-9_]+=',line))

def main():
parser=argparse.ArgumentParser()
parser.add_argument('experiment',choices=['aqs','all'])
parser.add_argument('--jdk',required=True)
args=parser.parse_args()
name='aqs'
jdk=Path(args.jdk).resolve();java=jdk/'bin/java';javac=jdk/'bin/javac';jar=jdk/'bin/jar';jcmd=jdk/'bin/jcmd'
version=execute([java,'-version'])
assert '21.0.5' in version and '21.0.5+11' in version
build=ROOT/'lab/build';build.mkdir(parents=True,exist_ok=True)
execute([javac,'-d',build,ROOT/'lab/AqsLab.java'])
dest=ROOT/'assets/05-aqs';dest.mkdir(parents=True,exist_ok=True);logs=[]
def run(*flags,timeout=25):
command=[java,*flags];out=execute(command,timeout);logs.append('$ '+' '.join(str(x) for x in command)+'\n'+out);return out
result = pairs(run('-cp', build, 'AqsLab'))
assert result['transferred_to_sync_queue'] == 'true' and result['resumed_while_signaller_holds_lock'] == 'false' and (result['hold_count_after_await'] == '2')
record={'experiment':name,'runtime':version.strip(),'os':platform.platform(),'executed_at':datetime.datetime.now(datetime.timezone.utc).isoformat(),'result':result}
(dest/'result.json').write_text(json.dumps(record,ensure_ascii=False,indent=2))
(dest/'execution.txt').write_text('\n\n'.join(logs))
print(json.dumps({'experiment':name,'result':result},ensure_ascii=False))

if __name__=='__main__':main()

实验记录

下面是本文配图采用的结果摘要;再次运行得到的计数、采样和日志时间会受环境影响。脚本会同时生成完整日志,诊断篇还会生成 JFR 文件。

展开本篇实验结果
1
2
3
4
5
6
7
8
9
{
"interrupted_waiter_cancelled": "true",
"condition_waiters_before_signal": "1",
"transferred_to_sync_queue": "true",
"resumed_while_signaller_holds_lock": "false",
"hold_count_before_await": "2",
"hold_count_after_await": "2",
"timed_acquire_returned_false": "true"
}

源码路线