2025 年 4 月 9 日 · JVM 与 Java 锁实践 04

两段代码都写着 synchronized,一段几乎没有开销,另一段让几十个请求排队。把解释停在“它是重量级锁”,很难指导修改。

我会沿三层看:Java 承诺了什么,字节码表达了什么,HotSpot 在这个版本如何执行。本文固定 JDK 21.0.5、默认 LockingMode=1,不会把其他版本的对象头图直接套过来。

先找锁对象,再找被保护的数据

实例同步方法锁 this;静态同步方法锁对应 Class 对象;同步代码块锁表达式求值得到的对象。要形成互斥,竞争者必须约定使用同一个对象。

1
2
3
4
5
6
7
8
private final Object guard = new Object();
private long balance;

void deposit(long amount) {
synchronized (guard) {
balance += amount;
}
}

另一个方法如果绕过 guard 直接访问 balance,就没有自动获得这把锁的保护。锁也不会禁止其他线程改对象里的所有字段,它约束的是遵守同一同步协议的访问路径。

我会优先用私有、稳定的锁对象,避免外部代码参与同一把锁的竞争。把可替换的业务引用当锁,或者随手用字符串常量作锁,都容易让同步边界变得难以控制。

javap 能看到入口,却不能看到全部运行时路径

同步代码块通常对应 monitorenter 与 monitorexit,异常路径也要保证退出。同步方法则可以通过方法标志 ACC_SYNCHRONIZED 表达,不一定在方法体里看到同样的指令组合。

Java 语法、字节码与运行时处理的分层

配套实验同时包含同步方法和同步块,javap -c -v -p 能看到上述两类信息。异常表帮助我们理解同步块为何能在异常退出时解锁,但 JIT 编译后可能把路径内联、优化;字节码不是机器指令的逐条翻译表。

1
"$JVM_LAB_JDK/bin/javap" -c -v -p -classpath lab/build MonitorLab

解释器、编译代码的快速路径与运行时慢路径会共同实现 monitor 语义。下面读 ObjectSynchronizer::enter,是在理解运行时处理的重要分支,不是在声称每一次成功加锁都完整调用相同的 C++ 函数。入口源码

这一版默认是 legacy stack-locking

globals.hpp 的声明把 LockingMode 默认值设为 LM_LEGACY,也列出了直接使用 monitor 和新 lightweight 路径。对照本机还可用解锁实验参数后的 PrintFlagsFinal 验证。

在 ObjectSynchronizer::enter 的 legacy 分支里,可以看到几步关键动作:检查对象的 mark、保存 displaced header、尝试 CAS 安装指向锁记录的标记;如果发现锁记录属于当前线程,则按重入路径处理。其余情况可能进入膨胀和 monitor 获取。

JDK 21.0.5 默认路径的源码阅读图

这里要区分两个“栈”:锁记录与线程栈相关,不表示整个被锁对象搬到了栈上;对象的正常存储与锁的元数据是不同问题。

也不能画一条所有请求都必须经过的“偏向→轻量→重量”流水线。这个版本的默认路径就应按源码本身解释。一次 CAS 失败也不等于该线程马上发生系统级睡眠;重试、重入、膨胀及实际竞争状态会影响下一步。

ObjectMonitor 把持有者、竞争者和条件等待者分开管理

进入膨胀路径后,ObjectMonitor::enter 会检查持有关系和重入,竞争处理继续走相应的 TryLock、TrySpin、EnterI 等逻辑。参与竞争的线程可能进入 _cxq 等结构,后续与 _EntryList 的处理衔接。ObjectMonitor::enter、EnterI

这些结构服务的是“谁在争取进入”,并不等于 Object.wait 的条件等待集合。把二者都叫“阻塞队列”,再把箭头随手连起来,会漏掉最重要的重新竞争阶段。

Monitor 内部两类等待的区别

退出 monitor 时,当前持有者需要处理重入计数、释放持有关系,以及适时唤醒竞争者。被唤醒只是有机会继续获取,不是已经直接拿到锁。ObjectMonitor::exit

这也不是一份严格 FIFO 公平性保证。线程调度、竞争路径和实现策略都会参与结果,业务不要通过“先调用 synchronized 的线程一定先进入”来设计协议。

interrupt 和 wait,作用在不同的等待位置

实验先让 owner 持有 monitor,再启动 contender。确认 contender 处于 BLOCKED 后调用 interrupt,它仍没有因此获得一个中断异常并取消 monitorenter;owner 释放后,contender 进入,能看到中断标志为 true。

检查 本次输出
owner 释放前 contender 状态 BLOCKED
owner 释放前是否进入临界区 false
释放后是否进入 true
获取后中断标志 true

这说明进入内置 monitor 的竞争,不等价于 ReentrantLock 的 lockInterruptibly。而 Object.wait 是可被中断影响的另一条路径,等待者还必须处理重新获取 monitor 后的返回或异常。wait 实现

实验第二部分让线程执行 wait。此时另一个线程能拿到同一 monitor;notifyAll 之后,只要通知者仍持有锁,等待者就还不能从等待协议中完成返回。

wait、通知、重新获取 monitor 的顺序

业务写法应该是:持锁检查条件,不满足就 while 等待;修改条件和通知也放在同一同步协议里。

1
2
3
4
5
6
synchronized (guard) {
while (!ready) {
guard.wait();
}
consumeReadyState();
}

while 是为了重新检查谓词,包括虚假唤醒、其他消费者先一步改变条件等情况。sleep 不会释放已经持有的 monitor;用 sleep 代替条件等待,还可能把其他线程一并堵住。具体等待规则见 JLS 17.2。

可见性来自同步关系,不是“锁住 CPU 缓存”

同一 monitor 的解锁与后续成功加锁建立规定的同步关系,使受保护写入能被后续遵守协议的读取观察到。实现要处理必要的编译与硬件排序,但不应把规范描述成“每次把所有 CPU 缓存刷回主存”。

这条语义不能保护无锁旁路读取,也不能把临界区里几个外部系统操作变成分布式事务。比如持锁更新内存后发邮件失败,synchronized 不会帮你撤销内存更新。

调优先缩短持有时间,再讨论换锁

我会先找持有者在临界区里做了什么:网络调用、磁盘 I/O、等待其他锁,往往比锁指令本身更值得修改。能把独立计算放到锁外,就缩小范围;需要交接共享状态时,再保持必要的原子步骤。

还要检查对象是否真的共享,避免用一个局部对象测试得出所有竞争场景的性能结论。逃逸分析和锁消除可能让这个基准根本没有测到预期的竞争。

在本文固定的 JDK 21 中,虚拟线程持有 monitor 期间发生某些阻塞操作,还涉及 carrier 被 pin 住的限制;评估时需要看该版本的虚拟线程说明和实际录制,不能只依据平台线程实验推导。本文实验全部使用平台线程。JDK 21 虚拟线程提案

另外,空闲 monitor 在这一版存在异步 deflation 相关处理。因此“膨胀过就永远不能改变状态”也不宜当作跨时间、跨版本的绝对规则;它与业务层读写锁的降级不是同一个概念。

源码与实验怎样对照

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

实验会保存 javap 输出和 monitorinflation 日志,并检查专门创建的 MonitorLab$Gate 是否出现膨胀记录。源码为 MonitorLab.java,结果为实验记录。

monitor 竞争、中断与 wait 的真实运行结果

读完这条链,我更关心的就不是给 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
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

public class MonitorLab {
static final class Gate {}
static final Gate gate = new Gate();
static volatile boolean open;
static void awaitState(Thread thread, Thread.State state) throws Exception {
long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(3);
while (thread.getState() != state && System.nanoTime() < deadline) Thread.sleep(1);
if (thread.getState() != state) throw new AssertionError("Expected " + state + ", got " + thread.getState());
}
public synchronized int synchronizedMethod() { return 42; }
public static void main(String[] args) throws Exception {
CountDownLatch acquired = new CountDownLatch(1), release = new CountDownLatch(1);
AtomicBoolean entered = new AtomicBoolean(), interrupted = new AtomicBoolean();
Thread owner = new Thread(() -> { synchronized(gate) {
acquired.countDown();
try { release.await(); } catch (InterruptedException error) { throw new RuntimeException(error); }
}}, "monitor-owner");
Thread contender = new Thread(() -> { synchronized(gate) {
entered.set(true); interrupted.set(Thread.currentThread().isInterrupted());
}}, "monitor-contender");
owner.start(); acquired.await(); contender.start();
awaitState(contender, Thread.State.BLOCKED);
contender.interrupt();
System.out.println("contender_before_release=" + contender.getState());
System.out.println("entered_before_release=" + entered.get());
release.countDown(); owner.join(3000); contender.join(3000);
if (!entered.get() || !interrupted.get()) throw new AssertionError();
System.out.println("entered_after_release=" + entered.get());
System.out.println("interrupt_flag_after_acquire=" + interrupted.get());
Thread waiter = new Thread(() -> { synchronized(gate) {
while (!open) try { gate.wait(); } catch (InterruptedException error) { return; }
}}, "monitor-waiter");
waiter.start(); awaitState(waiter, Thread.State.WAITING);
System.out.println("waiter_while_waiting=" + waiter.getState());
synchronized(gate) {
System.out.println("monitor_available_during_wait=true");
open = true; gate.notifyAll();
System.out.println("waiter_finished_before_notifier_unlock=" + !waiter.isAlive());
}
waiter.join(3000);
if (waiter.isAlive()) throw new AssertionError();
System.out.println("waiter_finished_after_unlock=true");
}
}

实验环境与运行脚本

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

将前面的 Java 示例保存为 lab/MonitorLab.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 monitor --jdk "$JVM_LAB_JDK"

Python 脚本无第三方依赖,只编译本篇 Java 示例,输出到本项目的 assets/04-monitor/。诊断采集仅针对脚本自己启动的实验 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
36
37
38
39
40
41
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=['monitor','all'])
parser.add_argument('--jdk',required=True)
args=parser.parse_args()
name='monitor'
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/MonitorLab.java'])
dest=ROOT/'assets/04-monitor';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
output = run('-Xms64m', '-Xmx64m', f'-Xlog:monitorinflation=trace:file={dest}/monitor.log:uptime,level,tags', '-cp', build, 'MonitorLab')
result = pairs(output)
text = (dest / 'monitor.log').read_text()
result['gate_monitor_inflation_seen'] = 'MonitorLab$Gate' in text
bytecode = execute([jdk / 'bin/javap', '-c', '-v', '-p', '-classpath', build, 'MonitorLab'])
(dest / 'javap.txt').write_text(bytecode)
assert 'monitorenter' in bytecode and 'monitorexit' in bytecode and ('ACC_SYNCHRONIZED' in bytecode)
assert result['contender_before_release'] == 'BLOCKED' and result['entered_before_release'] == 'false' and result['gate_monitor_inflation_seen']
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
10
11
{
"contender_before_release": "BLOCKED",
"entered_before_release": "false",
"entered_after_release": "true",
"interrupt_flag_after_acquire": "true",
"waiter_while_waiting": "WAITING",
"monitor_available_during_wait": "true",
"waiter_finished_before_notifier_unlock": "false",
"waiter_finished_after_unlock": "true",
"gate_monitor_inflation_seen": true
}

固定源码入口