夜雨聆风学习资料网

ARTICLE · 1379727

读一行JDK源码,说说虚拟线程为什么能让100万并发不崩

读一行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;    });}

为什么这么设计

把上面串起来,你会发现这套设计的取舍非常清晰:

  1. 不引入新的并发原语——java.lang.Thread 还是那个 Thread,LockSupport、synchronized、Future 全都照旧。目标是「最小迁移成本」,而不是「最优雅的新 API」。
  2. 把复杂度塞给 JVM 的 native 层(doYield、enterSpecial),业务层只看到一个「会睡觉的线程」。
  3. 用 ForkJoinPool 当默认调度器,复用现成的工作窃取(work-stealing)能力,一个成熟的调度器白嫖到手,不用自己再造轮子。
  4. 用 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 的真实源码,你可以自己去核对。

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

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

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

相关学习资料