夜雨聆风学习资料网

ARTICLE · 1372984

深入 JDK 源码:Java 24 到底怎么让 synchronized 不再锁死虚拟线程

深入 JDK 源码:Java 24 到底怎么让 synchronized 不再锁死虚拟线程

深入 JDK 源码:Java 24 到底怎么让 synchronized 不再锁死虚拟线程

先说个反直觉的事:synchronized 这个 Java 从 1.0 就有的关键字,一直到 JDK 21 都把虚拟线程(Virtual Thread)害得不轻。你在一个 synchronized 方法里做一次阻塞 I/O,整个 carrier 线程就被"钉死"了——虚拟线程想做的"百万并发"瞬间破功。

这事憋了三年,直到 JDK 24 的 JEP 491(Synchronize Virtual Threads without Pinning) 才算真正解决。而且改的不是 Java 层,是 JVM 的 monitor 实现。

今天这篇文章,我就带你把这段源码扒开看——它到底调了什么,为什么之前非 pin 不可,改动又干净在哪儿。

先搞清楚:虚拟线程到底怎么被"钉死"的

要理解这个 bug,得先记住虚拟线程最核心的一个机制:mount/unmount(挂载/卸载)。

虚拟线程本质是 JVM 调度到一堆 carrier 线程(平台线程)上跑的"轻量任务"。当虚拟线程要干活,JVM 把它 mount 到某个 carrier 上;当它阻塞了(比如等 socket),就 unmount 下来,把 carrier 还给调度器去跑别的虚拟线程。这一进一出,就是虚拟线程能便宜地撑起几十万并发的全部秘密。

那问题来了:synchronized 依赖的是对象上的 monitor(锁)。JVM 必须记录"当前是哪个线程持有这把锁",别的线程来了才能正确地排队等待。

关键的坑在于——JDK 21 到 23,JVM 记录的是"哪个平台线程持有锁",而不是"哪个虚拟线程持有锁"。

于是灾难就出现了。想象一下:

  1. 虚拟线程 VT-1 跑在 carrier CT-1 上;
  2. VT-1 进入 synchronized(obj),JVM 把 CT-1 记为锁的持有者(因为 JVM 眼里只有 CT-1);
  3. VT-1 在同步块里碰到阻塞 I/O,按正常逻辑应该 unmount、把 CT-1 还给调度器;
  4. 但 CT-1 现在被 JVM 记成"持有这把锁"。如果 CT-1 去跑另一个虚拟线程 VT-2,而 VT-2 恰好也要进 synchronized(obj),JVM 一看"CT-1 已经持有这锁了"——monitor 是可重入的——于是直接放行。

互斥,被打破了。 VT-2 在没有拿到锁的情况下进了一个本应互斥的临界区。

这个例子出自 openjdk.org/jeps/491 的原文思路。它解释了为什么 pinning 不是 JVM 偷懒,而是当时唯一能保证 synchronized 正确性的办法——你没法 unmount,因为一 unmount,锁的所有权就跟着 carrier 飘走了。

所以当时的实现只能选择"不 unmount":虚拟线程从拿到 monitor 开始,就被钉在自己的 carrier 上,直到 monitorexit。

源码里,pinning 长什么样

我们直接看 JDK 里虚拟线程的挂载/卸载代码。在 java.lang.VirtualThread 里,mount() 和 unmount() 是这样的(我节选自 OpenJDK src/java.base/share/classes/java/lang/VirtualThread.java):

privatevoidmount() {// 设置 carrier 线程Threadcarrier= Thread.currentCarrierThread();    setCarrierThread(carrier);    ...// 让 Thread.currentThread() 返回这个虚拟线程    carrier.setCurrentThread(this);}privatevoidunmount() {// 让 Thread.currentThread() 返回平台线程Threadcarrier=this.carrierThread;    carrier.setCurrentThread(carrier);// 断开与 carrier 的连接synchronized (interruptLock) {        setCarrierThread(null);    }    carrier.clearInterrupt();    ...}

单看这段,mount/unmount 本身挺干净。但关键在别处:虚拟线程一旦进入 synchronized,HotSpot 层的 ObjectMonitor 里,锁的 owner 字段记录的是当前平台的 JavaThread,也就是 carrier。

再看 VirtualThread 里那个延续体的钩子——VThreadContinuation 覆盖了 Continuation.onPinned:

privatestaticclassVThreadContinuationextendsContinuation {    VThreadContinuation(VirtualThread vthread, Runnable task) {super(VTHREAD_SCOPE, wrap(vthread, task));    }@OverrideprotectedvoidonPinned(Continuation.Pinned reason) {// 这里是 JDK 24 之前 pinning 会进来的地方    }}

Continuation.Pinned 这个枚举,在 JEP 491 落地之前,会包含 MONITOR_ENTER、MONITOR_WAIT 之类的理由——正是"因为想拿锁/想 wait 所以被钉住"的场景。JDK 24 之后,这些 monitor 相关的 pinning 理由被一批批移除了。

JEP 491 做了什么:把锁的所有者从 carrier 改成虚拟线程

解法一句话:让 JVM 改为记录"哪个虚拟线程持有锁",而不是哪个平台线程。 绑定关系在每一次 mount/unmount 时做账。

这样虚拟线程就可以安全地 unmount 了——因为不管它当前挂在哪个 carrier 上,JVM 都能通过账本知道"锁是 VT-1 的,跟 CT-1 没关系"。

我们翻 HotSpot 的 objectMonitor.cpp,能看到改动后的真实逻辑。在 monitor 竞争进入的路径上,出现了对虚拟线程的专门处理:

ContinuationEntry* ce = current->last_continuation();bool is_virtual = ce != nullptr && ce->is_virtual_thread();if (is_virtual) {notify_contended_enter(current, post_jvmti_events);    result = Continuation::try_preempt(current, ce->cont_oop(current));if (result == freeze_ok) {bool acquired = vthread_monitor_enter(current);if (acquired) {// 在尝试把 vthread 加入 _entry_list 的过程中,// 居然已经拿到锁了,于是取消抢占。// 还是会走 preempt stub,但不再 unmount,而是 thaw 继续执行。        }    }    ...}

这段是整件事的精华,我解释一下几个关键调用:

  • Continuation::try_preempt:尝试"抢占"当前虚拟线程。什么叫抢占?就是把虚拟线程的栈帧冻结(freeze)到堆里,让它从 carrier 上下来。freeze_ok 说明冻结成功,可以 unmount 了。
  • vthread_monitor_enter:虚拟线程版的 monitor 进入逻辑。这里做的就是把当前虚拟线程登记到 monitor 的等待队列(_entry_list)里,做基于虚拟线程身份的排队。
  • 注释里那段特别有意思:如果"正在把 vthread 加入等待队列"的过程中,锁恰好被释放、居然就拿到了,那就取消抢占——还是会走 preempt stub,但走的是 thaw(解冻)路径,继续执行而不是卸载。

还有一个细节,源码里明确写了队列的设计意图:

一个正在竞争的虚拟线程拿到锁之后,必须把自己从 _entry_list 里摘下来。而"退出的线程"会从 _entry_list 里挑一个"假定继任者(heir presumptive)"去 unpark。如果这个继任者是个已经卸载的虚拟线程,退出的线程会先尝试把它加进"待唤醒的 vthread 列表",成功后再去 unpark 一个专门的 unblocker 线程。

换句话说,锁的排队、唤醒,全部改成了虚拟线程粒度的调度,carrier 完全退出了锁所有权这条链路。

配套的,Object.wait() 和它的定时变体也做了同样的改造:虚拟线程在 synchronized 里调 wait(),现在也能 unmount;被 notify() 唤醒后,重新排队拿锁,流程跟上面一样。

为什么这么设计:从"钉死"到"账本"

你可能会问,为什么早期不直接做对?答案是这套"虚拟线程身份"的账本,是要在 mount/unmount 的每个关键路径上做同步的,开销不小。Loom 项目(Project Loom)选择在 JDK 21 先让虚拟线程上线、把 pinning 的坑显式暴露出来,用 jdk.tracePinnedThreads 让开发者自己排查,先把大头(那些不涉及 monitor 的阻塞 I/O)跑顺。等到 monitor 这套改动在 JDK 24 成熟、验证过,再一次性合入。

这个取舍是工程上的"分步走":先交付 90% 的价值,同时把剩下 10% 的坑标出来,而不是为了求完美再憋三年。代价就是中间这三年,社区搞了一场"把 synchronized 换成 ReentrantLock"的运动——很多库(包括 JDK 自己的一部分代码)为此做了迁移。

JEP 491 落地后,官方 JEP 里有这么一句收尾,我觉得是这套改动的定论:

一旦 synchronized 不再 pin 虚拟线程,你就可以纯粹根据"哪个更适合解决问题",在 synchronized 和 java.util.concurrent.locks 之间做选择。

别高兴太早:还有几类 pinning 没解决

JEP 491 只是干掉了 monitor 相关的 pinning,不代表"从此再无 pinning"。剩下几类,JFR(JDK Flight Recorder)的 jdk.VirtualThreadPinned 事件依然会触发,做虚拟线程上线前记得拿它过一遍:

残留 pinning 场景
为什么
常见程度
原生帧(native frames)
调用 JNI / Foreign Function API,原生代码可能持有裸栈指针,无法保证安全卸载
web 服务里少见
类加载 / 类初始化边界
类初始化器的特定阶段
偶发
本地文件 I/O(Linux)
JDK 目前没有生产可用的 io_uring 集成,文件读写仍会 pin
最常见的意外

最后那个文件 I/O 尤其值得留意。很多人以为"JEP 491 之后虚拟线程就能无脑铺开了",结果一跑才发现文件密集的代码路径还是有 pinning。InfoQ 一篇讲 JDK 24 之后虚拟线程落地经验的文章里有个挺重的话:pin 不再是主要风险了,真正的生产风险变成了"下游资源被打穿"。

道理也简单——虚拟线程把原来 servlet 线程池那个"天然限流"的天花板拆掉了,几十万并发同时冲向你的数据库连接池、下游 API 限流、文件描述符上限。瓶颈从"线程"转移到了"你后面那一堆东西"。

踩坑点小结

最后把自己趟过的、加上资料里反复被提到的几个点拼一下:

  1. JDK 24 之后别再为了躲 pinning 去重写 synchronized 了——那是 JDK 21~23 时代的建议,现在纯属过度设计。选 synchronized 还是 ReentrantLock,回到语义本身:要不要可中断、要不要 tryLock、要不要公平锁。

  2. jdk.tracePinnedThreads 这个系统属性没了。JDK 24 起它被移除了(它当初就是为排查 monitor pinning 设计的,会拖慢性能)。排查 pinning 统一走 JFR 的 jdk.VirtualThreadPinned 事件。

  3. 文件 I/O 在 Linux 上还是会 pin。如果你的虚拟线程服务做了大量本地文件读写,别默认它已经"无 pin 运行",上 JFR 实测一下。

  4. 锁竞争激烈时,虚拟线程在 _entry_list 上的排队开销比平台线程略高(多了 freeze/thaw 和虚拟线程身份的账本)。个别极端争用热点,ReentrantLock 的 AQS(基于 CAS 的乐观锁快速路径)可能仍是更省的选择——但这是性能微调,不是正确性问题。

  5. 上线前测下游。虚拟线程把并发天花板拆了,你后面那个连接池、那个限流、那个 FD 上限,才是下一个会报警的地方。


归根结底,JEP 491 是个非常"Java 官方"的改动:不引入任何新语法、不改你的代码,默默地把锁所有权的账本从 carrier 换成虚拟线程,让用了二十多年的 synchronized 在新并发模型下重新变得人畜无害。这种"向下兼容地解决一个底层 bug"的活,才是最难、也最见功力的。

如果你正在 JDK 21 上跑虚拟线程,被 pinning 折磨过,那升级到 24+ 这件事,优先级真的可以往上提一提。

回首页,搜索你想要的文档

在首页搜索框输入关键词,快速定位资料

文库首页搜索指引 立即搜索

相关学习资料