Skip to content

2.4-11 虚拟线程:调度模型、pinning、适用边界 ​

所属:02 Java 运行时 / 2.4 并发 分级:A 状态:◐ 初稿 关联:2.4-6、2.4-8、2.4-9、2.4-12、2.4-13

  • 题型:原理 / 对比 / 场景

  • 一句话结论:虚拟线程是 JVM 调度的 M:N 轻量线程,大量虚拟线程复用少量载体线程,阻塞时把栈卸到堆、释放载体;它适合高并发阻塞 I/O,不适合 CPU 密集和长 native 调用;不要池化,用 Semaphore/连接池限制下游并发,并警惕 synchronized/native 导致的 pinning(JDK 24 起 synchronized 不再 pin)。

  • 分层要点:

    1. 调度模型:虚拟线程实现上是 Thread 的子类,但不直接绑定 OS 线程。M 个虚拟线程映射到 N 个载体线程(carrier),载体是专用 ForkJoinPool 的 platform worker,默认并行度等于 CPU 核数,最大池大小默认 256,不是 commonPool。虚拟线程运行时 mount 到某个 carrier,阻塞时 unmount,栈帧保存为堆上的 StackChunk,唤醒后重新排队到某个 carrier 继续执行。
    2. 阻塞与 unmount:Thread.sleep、LockSupport.park、Condition.await、BlockingQueue.take/put、Semaphore.acquire、CountDownLatch.await、socket I/O 等阻塞点会让虚拟线程 park/unmount,载体去跑别的虚拟线程;ReentrantLock、StampedLock 不会 pin。synchronized 在 JDK 24 之前会 pin;JNI/native/FFM 调用会 pin;部分阻塞式文件 I/O、驱动内部 native 调用也可能占用载体,需要实测。
    3. pinning 的后果:虚拟线程在 pin 状态下无法 unmount,carrier 被占住,其他虚拟线程只能排队;载体池可能临时扩容到 maxPoolSize,但上限耗尽后吞吐会塌。JDK 24 的 JEP 491 消除了 synchronized 导致的 pinning,但 native/JNI 仍然存在;JDK 21–23 的热点同步块应评估换成 ReentrantLock。
    4. 创建与使用:Thread.ofVirtual().name("rpc-", 0).start(task)、Thread.startVirtualThread(task)、Executors.newVirtualThreadPerTaskExecutor()。后者不是线程池,而是“每个任务创建一个虚拟线程”的执行器;close() 会停止接收新任务并等待已提交任务结束。虚拟线程默认是 daemon,优先级设置无效,默认名字为空,生产上要显式命名便于排查。
    5. 与线程池的关系:虚拟线程不要池化,池化会引入队列、复用和上下文残留,违背“每任务一个轻量线程”的模型。I/O 密集的请求级任务用 per-task executor;CPU 密集仍用平台线程池或 ForkJoinPool;长 native/阻塞调用用平台线程池隔离;并发上限用 Semaphore、连接池、限流器控制,不能把“虚拟线程数量”当限流。需要队列、拒绝策略、优先级、定时调度的场景,平台线程池仍更合适。
    6. 上下文与可观测性:每个虚拟线程有自己的 ThreadLocalMap,百万级虚拟线程配大量 ThreadLocal 会放大内存;请求上下文优先用 ScopedValue(JDK 25 正式),它不可变、离开作用域自动恢复、可被结构化并发子任务继承。MDC、事务、SecurityContext 不会因为“换了个线程”自动传播,要显式传递。观测用 JFR 的 jdk.VirtualThreadStart/End/Pinned、-Djdk.tracePinnedThreads=full、jcmd Thread.dump_to_file -format=json;传统 jstack/ThreadMXBean 默认覆盖不到虚拟线程。
  • 图/流程:

text
M 个虚拟线程                         N 个载体线程(默认 ≈ CPU 核数)
VT1 ──mount──► carrier-1 ──────────► OS thread
VT2 ──mount──► carrier-2 ──────────► OS thread
VT3 ──park───► unmount,栈帧 → 堆上的 StackChunk
...
VTn

调度器:专用 ForkJoinPool(不是 commonPool)
阻塞点:sleep / park / await / take / acquire / socket I/O
text
虚拟线程执行 synchronized(JDK < 24)/ JNI / native
  └─ 无法 unmount → carrier 被占住
     └─ 其他虚拟线程排队;maxPoolSize 默认 256,扩容也会耗尽
java
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (var task : tasks) {
        executor.submit(task);
    }
}

// 并发上限不要靠“创建多少虚拟线程”,要靠信号量/连接池
Semaphore permits = new Semaphore(100);
permits.acquire();
try {
    // 调用下游
} finally {
    permits.release();
}
  • 版本/源码锚点:

    • JDK 21:JEP 444 虚拟线程正式;Thread.ofVirtual()、Executors.newVirtualThreadPerTaskExecutor();JFR 虚拟线程事件;jcmd Thread.dump_to_file 支持虚拟线程。
    • JDK 24:JEP 491,synchronized 不再固定载体线程。
    • JDK 25:JEP 506,ScopedValue 正式;结构化并发仍是 preview(JEP 505)。
    • Spring Boot 3.2+:spring.threads.virtual.enabled=true 可让应用任务/Tomcat 使用虚拟线程;Tomcat 10.1+ 提供虚拟线程执行器。
    • 源码:java.lang.VirtualThread、Thread.ofVirtual()、ThreadPerTaskExecutor、StackChunk、Continuation、ForkJoinPool 载体调度、jdk.VirtualThreadPinned 事件。
  • 平台线程 vs 虚拟线程:

维度平台线程虚拟线程
映射1:1 OS 线程M:N 复用载体线程
栈OS 栈,通常 MB 级堆上的 StackChunk,KB 级起
创建成本高低
阻塞阻塞 OS 线程unmount,释放载体
调度OSJVM + 专用 ForkJoinPool
池化常用不要池化
适用CPU 密集、native高并发阻塞 I/O
  • pinning 常见原因:
原因是否 pin处理
synchronized(JDK < 24)是换 ReentrantLock,或升级到 JDK 24+
JNI / native / FFM 调用是隔离到平台线程池,缩短调用
Thread.sleep / park / Condition.await否正常使用
ReentrantLock / StampedLock否优先用于虚拟线程热点
阻塞式文件 I/O / 驱动 native可能JFR 实测,必要时隔离
  • 虚拟线程 vs Reactive:
维度虚拟线程Reactor/响应式
编程模型同步阻塞式,代码直观异步操作符,学习曲线陡
调试栈完整,易定位调用链被拆散,较难
背压需 Semaphore/队列/连接池内建背压
适用I/O 密集、团队熟悉阻塞代码高吞吐流式、强背压
资源上限仍受下游连接/线程池限制同样受下游限制
  • 线程池选型:
场景建议
请求级 I/O、RPC fan-outnewVirtualThreadPerTaskExecutor
CPU 密集计算平台线程池 / ForkJoinPool
长 native、JNI、阻塞驱动平台线程池隔离
需要队列/拒绝策略/优先级ThreadPoolExecutor
定时/周期任务ScheduledThreadPoolExecutor
下游并发保护Semaphore、连接池、限流器
  • 追问链:

    1. 虚拟线程和平台线程的区别? → 平台线程 1:1 绑定 OS 线程,栈大、创建贵;虚拟线程是 JVM 调度的 M:N 轻量线程,栈在堆上,阻塞时 unmount,适合大量阻塞 I/O。
    2. M:N 调度怎么工作? → 多个虚拟线程复用少量载体线程;虚拟线程 mount 到 carrier 执行,遇到阻塞点 unmount,carrier 去跑其他虚拟线程,唤醒后重新排队。
    3. 虚拟线程阻塞时发生了什么? → 栈帧被保存到堆上的 StackChunk,虚拟线程状态变为 parked,carrier 被释放;unpark 后由调度器重新安排到某个 carrier。
    4. 哪些操作会让虚拟线程 unmount? → Thread.sleep、LockSupport.park、Condition.await、BlockingQueue.take/put、Semaphore.acquire、CountDownLatch.await、socket I/O 等虚拟线程感知的阻塞点。
    5. pinning 是什么? → 虚拟线程无法从 carrier 上卸下,carrier 被占住;常见于 JDK 24 前的 synchronized、JNI/native/FFM、部分阻塞式文件 I/O。
    6. 怎么检测 pinning? → JFR 的 jdk.VirtualThreadPinned,或启动参数 -Djdk.tracePinnedThreads=full 打印 pinned 栈;结合 jcmd Thread.dump_to_file 和压测。
    7. 为什么不要池化虚拟线程? → 虚拟线程创建成本低,池化会引入队列、复用、上下文残留和额外管理;正确做法是每任务一个,靠信号量/连接池限制下游并发。
    8. 虚拟线程适合 CPU 密集吗? → 不适合。载体线程数约等于 CPU 核数,虚拟线程再多也不能增加 CPU 并行度,反而增加调度开销;CPU 密集用平台线程池/ForkJoinPool。
    9. 虚拟线程能替代线程池吗? → 能替代“请求级阻塞 I/O”的线程池,不能替代所有池;CPU 密集、native、需要队列/拒绝策略/定时任务的场景仍用平台线程池。
    10. 怎么限制并发? → 用 Semaphore、数据库连接池、HTTP 连接池、限流器;不要用“创建多少虚拟线程”当限流,否则只是把排队从线程池挪到了内存。
    11. 虚拟线程和 ThreadLocal 怎么相处? → 每个虚拟线程有自己的 ThreadLocalMap,量大时内存放大;请求上下文优先 ScopedValue,必须用 ThreadLocal 时控制数量并及时 remove。
    12. ScopedValue 和 ThreadLocal 的区别? → ScopedValue 不可变、绑定作用域、离开自动恢复、可被结构化并发子任务继承;ThreadLocal 可变、跟随线程生命周期、需要手动清理。
    13. 虚拟线程和 synchronized 的关系? → JDK 21–23 的 synchronized 会 pin 载体,热点同步块考虑 ReentrantLock;JDK 24 的 JEP 491 消除了这部分 pinning。
    14. 虚拟线程和 Reactive 怎么选? → 团队熟悉阻塞式代码、I/O 密集、需要简单调试选虚拟线程;需要强背压、流式组合、已有响应式栈选 Reactor;两者都要做下游限流。
    15. CompletableFuture 怎么用虚拟线程? → 显式传 newVirtualThreadPerTaskExecutor() 作为 Executor;默认 supplyAsync 用 commonPool,不是虚拟线程;回调里避免阻塞。
    16. 虚拟线程和结构化并发? → 虚拟线程负责“轻量”,结构化并发负责“任务生命周期”:子任务在父作用域结束前完成或取消,避免孤儿任务;JDK 25 仍是 preview。
    17. 虚拟线程怎么观测? → JFR 的 jdk.VirtualThreadStart/End/Pinned、jcmd Thread.dump_to_file -format=json、Micrometer 指标、线程命名;传统 jstack/ThreadMXBean 覆盖不到虚拟线程。
    18. Spring Boot 怎么启用虚拟线程? → Spring Boot 3.2+ 设置 spring.threads.virtual.enabled=true,Tomcat 10.1+ 使用虚拟线程执行器;@Async 要单独配置虚拟线程执行器,MDC/事务上下文要显式传播。
    19. 迁移到虚拟线程的主要风险? → synchronized/native pinning、ThreadLocal 内存放大、下游连接池被打满、MDC/事务/安全上下文丢失、无界任务导致 OOM、观测工具不覆盖。
    20. 虚拟线程会不会 OOM? → 会。虽然单线程栈小,但任务/队列无界、ThreadLocal 大对象、StackChunk 深栈、下游阻塞导致任务堆积,都会耗尽堆或连接;要限并发、设超时、做背压。
    21. 虚拟线程和数据库连接池? → 虚拟线程可以等待连接,但连接池大小仍是硬上限;大量虚拟线程同时抢连接会排队/超时,应该用信号量或连接池并发数控制,不要无限创建。
    22. 虚拟线程调度器和 commonPool 是同一个吗? → 不是。虚拟线程使用专用 ForkJoinPool 作为载体调度器,commonPool 是另一套;parallelStream/默认 CompletableFuture 不会自动跑在虚拟线程上。
  • 生产案例/取舍(示例,替换成你的项目):

    • 订单聚合接口原来用 200 个平台线程的池做 RPC fan-out,扩容后线程数成为瓶颈;改成每请求一个虚拟线程,吞吐上升,但下游连接池被打满;加 Semaphore + 连接池上限后稳定。
    • 某个老库在热点路径大量 synchronized,JDK 21 下 JFR 显示 jdk.VirtualThreadPinned 频繁;把锁换成 ReentrantLock 后 pinning 消失,或升级 JDK 24 利用 JEP 491。
    • JDBC 驱动内部走 native,虚拟线程压测时载体被占满;把该调用隔离到平台线程池,虚拟线程只负责编排。
    • 每个请求用 ThreadLocal 存用户上下文和大对象,虚拟线程数量上来后堆内存暴涨;改用 ScopedValue 传不可变上下文,减少 ThreadLocal。
    • Spring Boot 3.2 打开虚拟线程后,@Async 仍走默认执行器,MDC 丢失;显式配置虚拟线程 TaskExecutor 和 TaskDecorator。
    • 迁移时直接把 newFixedThreadPool(500) 换成 per-task executor,但没有限制下游并发,故障时任务堆积 OOM;补信号量、超时、熔断后才上线。
    • 取舍:虚拟线程让“阻塞代码”变便宜,但不会让下游变快;它简化编程模型,不替代背压、连接池、限流和可观测性。
  • 易错点:

    • 把虚拟线程池化,或继续用 ThreadPoolExecutor 的 core/max 思维。
    • 用虚拟线程跑 CPU 密集任务,以为线程越多越快。
    • 不限制并发,创建百万虚拟线程打满下游或堆。
    • 忽略 synchronized(JDK < 24)/JNI/native 的 pinning。
    • 认为 ReentrantLock 也会 pin;实际不会。
    • 大量使用 ThreadLocal,忽略每个虚拟线程一份 map。
    • 认为 MDC、事务、SecurityContext 会自动传播到虚拟线程。
    • 用 jstack/ThreadMXBean 找不到虚拟线程,误以为任务没跑。
    • 认为 CompletableFuture.supplyAsync 默认用虚拟线程。
    • 认为 parallelStream 会用虚拟线程。
    • per-task executor 不 close(),任务生命周期失控。
    • 把虚拟线程当“无限连接池”,忽略数据库/HTTP 连接上限。
  • 30 秒口述稿:

虚拟线程是 JVM 调度的 M:N 轻量线程,很多虚拟线程复用少量载体线程;阻塞时把栈卸到堆、释放载体,所以适合高并发阻塞 I/O。它不适合 CPU 密集和长 native 调用;不要池化,用 Semaphore/连接池限制下游并发。JDK 24 前 synchronized 会 pin,native/JNI 也会 pin,用 JFR 或 tracePinnedThreads 检测。每个虚拟线程有自己的 ThreadLocal,量大会放大内存,请求上下文优先 ScopedValue。

  • 3 分钟展开顺序:结论(M:N + 阻塞 I/O)→ carrier/ForkJoinPool/StackChunk → mount/unmount 与阻塞点 → pinning 原因与检测 → 创建方式与不要池化 → 并发限制/连接池 → ThreadLocal/ScopedValue/MDC → 与平台线程池、Reactive 的选型 → 迁移风险与观测 → 生产案例。