ARTICLE · 1379727
读一行JDK源码,说说虚拟线程为什么能让100万并发不崩
读一行 JDK 源码,说说虚拟线程为什么能让 100 万并发不崩
Java 21 最重磅的特性,没有之一,是虚拟线程(JEP 444)。
表面上看它解决的是老生常谈的并发问题:以前服务器一台机器撑死几千个线程,因为每个平台线程都 1:1 绑一个操作系统线程,每个还要预留一段固定大小的栈(默认约 1MB)。线程一多,先别谈 CPU 调度,光内存就顶不住。虚拟线程把这个上限直接拉到百万级。
但网上聊这个特性的文章,绝大部分停在「能建很多线程」这句口号就结束了。今天这篇不这样,我把 OpenJDK 里 java.lang.VirtualThread 和 jdk.internal.vm.Continuation 的源码翻出来,一行一行看它到底怎么实现的。
先说结论,后面全是证据:虚拟线程的魔法,核心就是「把栈搬到堆上」+「一个可中断、可恢复的函数」+「遇到阻塞就换人」。
一句话原理:栈帧上堆 + 有栈协程
虚拟线程不是操作系统线程,它是 JVM 自己调度的轻量线程。关键在它的 class 注释里写得明明白白:
/** * A thread that is scheduled by the Java virtual machine rather than the operating * system. */finalclassVirtualThreadextendsBaseVirtualThread { ...privatestaticfinalContinuationScopeVTHREAD_SCOPE=newContinuationScope("VirtualThreads");privatestaticfinalForkJoinPoolDEFAULT_SCHEDULER= createDefaultScheduler(); ...privatefinal Executor scheduler;privatefinal Continuation cont;privatefinal Runnable runContinuation;三个字段就暴露了全部底牌:
scheduler:默认是一个ForkJoinPool,负责实际把虚拟线程「挂」到某个平台线程(叫 carrier thread,载体线程)上执行;cont:一个Continuation,这就是「可中断、可恢复的函数」;runContinuation:一个 Runnable,扔给 scheduler 去跑。
而 Continuation 的注释更直白:
/** * A one-shot delimited continuation. */publicclassContinuation { ...private StackChunk tail;privateboolean done;privatevolatileboolean mounted;StackChunk 就是「搬到堆上的栈」。 传统线程的调用栈是操作系统在内存里连续分配的一块真实栈;虚拟线程的「栈」则是一串挂在堆上的 StackChunk 链表。所以一个虚拟线程不用预留 1MB,它用多少、占多少,初始只有几百字节到几 KB。
这就是为什么你能一口气建一百万个虚拟线程而内存不崩——因为它压根没有为每个线程铺一条 1MB 的红毯。
状态机:一个线程的一生
VirtualThread 里有一张注释极清晰的 state 状态图,直接翻译过来就是虚拟线程的完整生命周期:
NEW -> STARTED // Thread.startSTARTED -> TERMINATED // 启动失败STARTED -> RUNNING // 第一次真正跑起来RUNNING -> PARKING // 线程尝试阻塞(park)PARKING -> PARKED // cont.yield 成功,线程被摘下来(unmounted)PARKING -> PINNED // cont.yield 失败,线程被「钉」在载体线程上PARKED -> RUNNABLE // 被唤醒(unpark)或被打断PINNED -> RUNNABLE // 被唤醒或被打断RUNNABLE -> RUNNING // 继续执行RUNNING -> YIELDING // 主动 Thread.yieldRUNNING -> TERMINATED // 跑完了这里的核心动作是 mount(挂载) 和 unmount(卸载):当虚拟线程真正要跑代码时,JVM 把它「mount」到一个载体线程上;当它遇到阻塞(比如 Thread.sleep、IO 等待、拿不到的锁),就「unmount」下来,让出这个载体线程去跑别的虚拟线程。
关键点:unmount 的那一刻,虚拟线程的栈帧被冻结成 StackChunk 留在堆上,载体线程转去跑别人,等条件满足再 mount 回来、从冻结点继续。 全程载体线程不阻塞。
核心机制:Continuation 的 yield 和 enter
「摘下来」这件事,代码里走的是 yieldContinuation() → Continuation.yield() → doYield():
// VirtualThread 里privatebooleanyieldContinuation() { notifyJvmtiUnmount(true); unmount(); // 先把载体线程让出来try {return Continuation.yield(VTHREAD_SCOPE); // 真正的「冻结」 } finally { mount(); // 等醒来再 mount 回来 notifyJvmtiMount(false); }}Continuation.yield() 最终落到这个 native 方法上:
@IntrinsicCandidateprivatenativestaticintdoYield();doYield() 是整个虚拟线程里最「黑」的地方——它是 JVM 的 intrinsic,会把当前载体线程的 Java 栈冻进 StackChunk,然后直接跳回 yield0 的调用点,就像这段栈空间「凭空返回」了一样。恢复时反过来:
@IntrinsicCandidateprivatenativestaticvoidenterSpecial(Continuation c, boolean isContinue, boolean isVirtualThread);enterSpecial 把之前冻住的 StackChunk 重新摊回到栈上,从上次 doYield 之后的位置继续执行。对运行在上面的业务代码来说,它只是睡了一觉,根本没感知到自己被「搬」过家。
这就是 有栈协程(stackful coroutine):不同于 JS 的 async/await 那种「无栈、需要把代码重写成回调」的模型,虚拟线程保留了完整调用栈,所以 Thread.sleep、synchronized、阻塞 IO 这些老代码几乎一行不用改就能直接享受虚拟线程的红利。
阻塞如何触发换人:park 的入口
那普通代码里的一次 LockSupport.park() 是怎么变成「卸载 + 换人」的?回到 VirtualThread,park 的逻辑会先尝试 yieldContinuation():
privatevoidafterYield() {ints= state();if (s == PARKING) { setState(PARKED); notifyJvmtiUnmount(false);// 关键:park 期间可能已经被 unpark 了if (parkPermit && compareAndSetState(PARKED, RUNNABLE)) {// 用 lazy submit,尽量在当前载体线程本地队列继续跑,保持缓存局部性 lazySubmitRunContinuation(ct.getPool()); } } ...}看到 lazySubmitRunContinuation 了吗——它用的是 ForkJoinPool.lazySubmit,把续跑任务尽量塞进当前载体线程自己的工作队列。为什么?因为刚从同一个线程上卸载下来,栈还在 CPU 缓存里热乎着,原地续跑能显著避免缓存的冷启动。这是很讲究的一处性能优化。
杀手锏变坑:pin 住这件事
虚拟线程最大的「但书」,也是实际用起来最容易踩的坑,藏在 Continuation 的这个枚举里:
publicenumPinned { NATIVE, // 栈上有 native 帧 MONITOR, // 持有 synchronized 锁 CRITICAL_SECTION // 处于临界区}当 doYield() 发现当前虚拟线程正卡在 native 代码里、或者正占着一个 synchronized 监视器,它无法把这个线程的栈安全冻结搬走——于是 yield 失败,返回非 0,状态从 PARKING 走到 PINNED:
PARKING -> PINNED // cont.yield failed, thread is pinned被 pin 住的线程没法卸载,会一直占着那条载体线程。如果一个虚拟线程在一个 synchronized 块里做了个很慢的 IO,那它就把这条 OS 线程拖住了——虚拟线程的低成本优势瞬间归零。
Java 24 的 JEP 491(同步非 pin 化)专门解决 synchronized 导致 pin 的问题,但 Java 21 时代这是实打实的坑。所以官方文档反复强调:
在虚拟线程里,能用
ReentrantLock就别用synchronized,好歹别在同步块里做阻塞 IO。
另外还有两个经典坑:ThreadLocal 滥用(虚拟线程百万级并发,每个 thread-local 变量都是百万份开销),以及池化思维残留——很多人习惯用固定线程池,但虚拟线程的正确用法是每个任务一个线程、用完即弃:
try (varexecutor= Executors.newVirtualThreadPerTaskExecutor()) { executor.submit(() -> { Thread.sleep(Duration.ofSeconds(1)); // 睡眠期间线程被卸载,载体线程去跑别人return42; });}为什么这么设计
把上面串起来,你会发现这套设计的取舍非常清晰:
不引入新的并发原语—— java.lang.Thread还是那个Thread,LockSupport、synchronized、Future全都照旧。目标是「最小迁移成本」,而不是「最优雅的新 API」。把复杂度塞给 JVM 的 native 层( doYield、enterSpecial),业务层只看到一个「会睡觉的线程」。用 ForkJoinPool当默认调度器,复用现成的工作窃取(work-stealing)能力,一个成熟的调度器白嫖到手,不用自己再造轮子。用 StackChunk惰性扩栈,栈按需增长、可被 GC 回收,这是「能建百万线程」的真正原因。
代价也清楚:JVM 要额外维护一套「栈搬迁」的机制,某些 native 交互和 synchronized 场景下会退化(pin),调试和 profiling 工具也要专门适配。但和「thread-per-request 直接线性扩展」这个收益比起来,完全划算。
收个尾
虚拟线程不是银弹——CPU 密集的并行计算它帮不上忙(那还是 parallelStream 的活儿),但凡是 IO 密集、高并发、thread-per-request 的服务端场景,它就是近十年 Java 并发领域最实在的一次升级:百万并发、代码几乎不用改、工具链照旧。
下次有人跟你吹「Java 终于赶上 Go 的 goroutine 了」,你可以补一句更准确的话:Java 学到的不是 goroutine 的表象,而是「栈上堆 + 阻塞即让出」这个底层套路,并且打包成了一个对老代码极度友好、还带完整栈帧的版本。
上面所有代码片段,都来自 OpenJDK 仓库 jdk-21 标签下 java.base/share/classes/java/lang/VirtualThread.java 和 jdk/internal/vm/Continuation.java 的真实源码,你可以自己去核对。















































































