知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 虚拟线程(JDK 21 Loom) > 导读:本文从"高并发 IO 服务里,线程数被操作系统内核线程上限和每线程内存开销卡死"这个痛点出发,把平台线程与虚拟线程的本质差异、Continuation 的挂起/恢复机制、载体线程与 ForkJoinPool 调度、三种创建方式、以及 pinning、ThreadLocal、池化资源、连接池等常见坑逐项讲透,最后给出生产迁移建议与排查手段。适合有 Java 并发基础、正在评估或落地 JDK 21 虚拟线程的同学。 ## 一、先建立全局认知 ### Q:平台线程(Platform Thread)和虚拟线程(Virtual Thread)的本质差异是什么? A:结论先行——平台线程是操作系统线程的一层薄封装,与内核线程 1:1 映射;虚拟线程(Virtual Thread)是由 JDK 自己实现的轻量线程,由 JVM 的调度器以 M:N 的方式复用到少量**载体线程(carrier thread)**上,因此线程数量不再被内核线程数直接限制。 先把术语定义清楚: - **平台线程(platform thread)**:传统 `java.lang.Thread`,其背后就是一个操作系统线程(OS thread / 内核线程),由操作系统的调度器分配 CPU 时间片。 - **虚拟线程(virtual thread)**:由 JDK(而不是操作系统)提供的轻量线程,大量虚拟线程共享少量平台线程。 - **载体线程(carrier thread)**:承载虚拟线程运行的平台线程。虚拟线程"挂载(mount)"到载体线程上执行,遇到阻塞时"卸载(unmount)"并让出载体线程。 为什么这个 1:1 与 M:N 的差别是根本性的?因为它把"并发任务的数量"和"操作系统线程的数量"这两件事解耦了。  *图:虚拟线程(JDK 21 Loom)调度模型:平台线程 1:1 与虚拟线程 M:N* ```text 平台线程(1:1) 虚拟线程(M:N) ┌────────────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │ Java 线程 │ │ VT-1 │ │ VT-2 │ │ VT-3 │ │ ... │ └─────┬──────┘ └───┬──┘ └──┬───┘ └──┬───┘ └──┬───┘ │ 1:1 └───────┼────────┼────────┘ ┌─────┴──────┐ ┌───────────┴────────┴───────────┐ │ 内核线程 │ │ JVM 调度器 + ForkJoinPool │ └─────┬──────┘ └───────────────┬───────────────┘ ┌─────┴──────┐ ┌───────────────┴───────────────┐ │ CPU 核心 │ │ 载体线程(数量通常 ≈ CPU 核数) │ └────────────┘ └───────────────┬───────────────┘ ┌───────────────┴───────────────┐ │ 内核线程 / CPU │ └────────────────────────────────┘ ``` 需要说明:上面"载体线程数量 ≈ CPU 核数"是默认调度器的典型取值,具体数值与 JDK 版本、可用处理器数、容器环境(`Runtime.availableProcessors()` 在 JDK 10 及以后会感知部分容器 CPU 限制)有关,需结合所用 JDK 版本与环境确认。 ### Q:虚拟线程到底解决了什么问题? A:结论先行——它解决的是"**高并发、以阻塞式 IO 为主**"的服务里,用一个操作系统线程服务一个请求所带来的线程数量上限与内存开销问题,让你可以继续写"一个请求一个线程"的同步代码,同时获得很高的并发能力。 为什么原来的模型会卡住?因为每个平台线程都对应一个内核线程,成本不低: - 每个平台线程有自己的栈(常见默认栈大小在几百 KB 到 1 MB 量级,可用 `-Xss` 调整),线程多了内存开销很可观。 - 内核线程的创建、销毁、上下文切换都需要内核参与。 - 线程数量一旦上去,调度与缓存局域性都会变差。 而在典型的请求-响应服务里,线程真正"干活"的时间往往很短,大部分时间在**阻塞等待**——等数据库返回、等下游 HTTP 接口、等磁盘 IO。此时线程只是"占着资源在睡觉"。虚拟线程的设计目标就是让这种"睡觉"变得几乎免费:虚拟线程阻塞时卸载,让出载体线程去跑别的虚拟线程。 这里可以用**利特尔法则(Little's Law)**来理解:对固定的请求处理时长(延迟),并发数必须随吞吐量线性增长。也就是说,想提高吞吐,就要能同时挂起更多请求。虚拟线程把"能同时挂起多少请求"的天花板抬高了,而不是让单个请求变快。 **适合**:`Thread.sleep`、socket/HTTP 调用、数据库访问、文件 IO 等以等待为主的任务。 **不适合**:纯 CPU 计算、需要大量栈上计算且几乎不阻塞的任务。 ### Q:虚拟线程和线程池、反应式编程(Reactive Programming)是什么关系? A:结论先行——虚拟线程让你**保留"一个请求一个线程"的同步阻塞写法**去拿高并发;它与线程池是"替代关系"(不再需要靠池化节省线程),与反应式是"不同取舍、可共存"的关系,而不是简单的谁淘汰谁。 - 与**线程池**:线程池的核心价值是复用昂贵线程、限制并发数。虚拟线程非常廉价,无需复用,因此主流用法是"每个任务新建一个虚拟线程",而不是把虚拟线程放进固定大小的池里。 - 与**反应式**:反应式(如 Reactor、RxJava)通过异步回调 / 数据流避免阻塞线程,代价是编程模型变了、调试和栈追踪更复杂。虚拟线程让同步写法也能获得高并发,多数阻塞型服务可以用它替换掉反应式的复杂度。但反应式的**背压(backpressure)**、流式处理、SSE/WebSocket 等场景仍有独立价值,虚拟线程并不能替代背压机制。 一句话取舍:**阻塞式请求-响应服务优先考虑虚拟线程;对数据流背压、流式推送敏感的场景,反应式仍是对的选择。** ## 二、理解核心机制 ### Q:虚拟线程是如何做到"阻塞却不占用内核线程"的?Continuation 是什么? A:结论先行——虚拟线程的挂起/恢复建立在**续体(Continuation)**之上:当虚拟线程到达一个 JVM 能识别的阻塞点,它会把当前执行状态(栈帧)从载体线程的栈搬到堆上的一个数据结构里,然后"卸载"、让出载体线程;等事件就绪再"重新挂载"到某个载体线程继续执行。 先给定义: - **Continuation(续体)**:一段可以被暂停、之后再从暂停处继续执行的代码及其执行状态。可以把它想成"可以冻结和解冻的调用栈"。 需要强调:Continuation 在 JDK 中是内部实现机制(`jdk.internal.vm.Continuation` 属于内部 API),**不是普通开发者可以直接依赖的公开 API**。这里只讲原理,不鼓励去调用它。 挂起与恢复的过程大致如下: ```text 运行中:虚拟线程挂载在载体线程上,栈帧位于载体线程的栈里 carrier(OS thread) ──[ VT 的栈帧 ]──> 执行用户代码 到达阻塞点(如 Socket.read、LockSupport.park): 1) 把 VT 的栈帧从载体线程栈拷贝到堆上的存储区 2) 把 VT 标记为"已阻塞/已挂起",从载体线程卸载(unmount) 3) 载体线程被释放,调度器立刻挂载下一个可运行的 VT 事件就绪(如字节到达、被 unpark): 4) 把栈帧恢复回某个载体线程的栈,VT 重新挂载(mount)并从断点继续执行 ``` 要理解"哪些阻塞点会触发卸载":JDK 已经把 `java.util.concurrent` 与网络 IO 打通——`LockSupport` 的 `park/unpark` 被改造为对虚拟线程友好,因此 `ReentrantLock`、`Semaphore`、阻塞队列(`BlockingQueue`)等都能良好配合虚拟线程;`java.net` 与 `java.nio.channels` 中的阻塞操作在虚拟线程上执行时会释放底层平台线程(以上为 JDK 21 起的公开设计,具体覆盖范围需结合所用 JDK 版本确认)。 **不适用边界**:如果一段代码既不调用这些被识别的阻塞点,又是一直在做计算,那么它不会卸载,虚拟线程和平台线程的表现没有本质差别。 ### Q:载体线程由谁提供?调度器是怎么工作的? A:结论先行——虚拟线程的默认调度器基于 **ForkJoinPool**,采用**工作窃取(work-stealing)**模式,载体线程数默认与可用处理器数相关。它是一种"非公平、抢占式"的调度,**不保证**多个虚拟线程的执行顺序或公平性。 关键点: - 一个虚拟线程在任意时刻最多挂载在**一个**载体线程上;一个载体线程在任意时刻只跑**一个**虚拟线程。 - 虚拟线程的挂载/卸载对上层代码是透明的,你不需要也不能手动指定载体线程。 - 由于调度基于 ForkJoinPool,会复用其线程池语义(如工作窃取队列)。JDK 提供了若干系统属性用于调整调度器参数(例如与并行度、池大小相关的属性),这些属性名与默认值在不同版本可能调整,**需结合所用 JDK 版本确认**,生产上除非有明确压测结论,不建议随意改动。 这里有一个容易踩的坑:**虚拟线程的调度器本身工作在固定数量的载体线程上,如果载体线程被长期占用(pinning,见下文),可用的载体线程就会被耗尽**,此时虚拟线程会像平台线程一样卡住。 ### Q:用一张图描述一个虚拟线程从创建到结束的生命周期。 A:结论先行——虚拟线程的生命周期与平台线程类似(NEW → RUNNABLE → … → TERMINATED),但增加了"挂载/卸载"这一维度:RUNNABLE 也可能处于"已调度但未挂载"的状态。  *图:虚拟线程挂载、卸载、唤醒与终止的状态流转* ```text NEW ──start()──> RUNNABLE ──挂载──> 在载体线程上执行 ▲ │ │ ├─ 到达阻塞点 ──> PARKED(卸载,让出载体) │ │ │ └──────────── 事件就绪:重新入调度队列 ◀─────┘ │ 运行结束 ──> TERMINATED ``` 要注意两点差异:其一,虚拟线程**始终是守护线程(daemon)**,且不支持设置优先级、线程组也不像平台线程那样可自定义;其二,虚拟线程对象同样可以被 `interrupt()`,中断语义与平台线程一致。 ## 三、创建与使用虚拟线程 ### Q:虚拟线程有哪几种创建方式?分别适合什么场景? A:结论先行——主要有三种方式:`Thread.startVirtualThread(Runnable)`(单发)、`Thread.ofVirtual()` 构建器(需要命名/工厂时)、`Executors.newVirtualThreadPerTaskExecutor()`(服务端批量提交任务,**最推荐**)。 方式一,单发一个虚拟线程,适合演示或极少量场景: ```java // 目标:启动一个虚拟线程执行任务,不关心返回值与命名 public class StartOne { public static void main(String[] args) throws InterruptedException { Thread t = Thread.startVirtualThread(() -> { System.out.println("virtual=" + Thread.currentThread().isVirtual()); }); t.join(); } } ``` 关键点:`Thread.startVirtualThread(Runnable)` 静态方法直接创建并启动一个虚拟线程并返回 `Thread`;`Thread.isVirtual()` 用来判断当前线程是否为虚拟线程(JDK 21 起可用),上面输出为 `virtual=true`。`join()` 会等待该线程结束。 方式二,用构建器命名、拿到工厂,适合需要对线程命名以便排查、或对接需要 `ThreadFactory` 的库: ```java import java.util.concurrent.ThreadFactory; // 目标:创建命名规则为 request-1, request-2 ... 的虚拟线程工厂 public class VirtualFactory { public static void main(String[] args) throws InterruptedException { ThreadFactory factory = Thread.ofVirtual().name("request-", 1).factory(); Thread t = factory.newThread(() -> System.out.println(Thread.currentThread().getName())); t.start(); t.join(); // 预期输出 request-1 } } ``` 关键点:`Thread.ofVirtual()` 返回 `Thread.Builder.OfVirtual`;`name(prefix, start)` 生成递增命名的线程,便于在线程转储、日志中区分。`factory()` 得到 `ThreadFactory`,`newThread(Runnable)` 返回的是**尚未启动**的线程,需要显式 `start()`。 方式三,`Executors.newVirtualThreadPerTaskExecutor()`,这是服务端主流用法: ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; // 目标:提交一批阻塞型任务,每个任务一个虚拟线程 public class VirtualExecutor { public static void main(String[] args) throws Exception { // ExecutorService 自 JDK 19 起实现 AutoCloseable,close() 会等待已提交任务完成 try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) { Future<String> f = executor.submit(() -> { Thread.sleep(1000); // 会触发卸载,让出载体线程 return "done:" + Thread.currentThread().isVirtual(); }); System.out.println(f.get()); // 预期输出 done:true } // 此处 close():不再接受新任务,并等待已提交任务结束 } } ``` 关键点:该执行器**为每个任务创建一个新的虚拟线程**,不做线程复用;`try-with-resources` 的 `close()` 语义是"不再接收新任务并等待已提交任务完成"(`ExecutorService` 自 JDK 19 起是 `AutoCloseable`)。返回的 `Future.get()` 和普通线程池用法一致。 **适用与不适用**: - 适用:大量、独立、以阻塞等待为主的请求任务。 - 不适用:需要限制并发数的任务(这种执行器不设上限,要限流应改用 `Semaphore` 或自定义策略);纯 CPU 计算任务。 ### Q:为什么不要把虚拟线程池化? A:结论先行——虚拟线程**极其廉价、就是设计成用完即弃的**,池化会抵消它的核心优势,还会引入状态残留等新问题,所以不要用固定大小的池去"缓存"虚拟线程。 原因有三: 1. **没有复用的必要**:创建虚拟线程的开销很小,池化的收益(省下线程创建成本)在这里几乎为零,反而多了一层队列与调度开销。 2. **状态残留**:池化意味着线程会被复用,`ThreadLocal` 里残留的上一个任务状态、未清理的上下文会串到下一个任务,比平台线程池更难排查。 3. **限流需求应显式表达**:如果你的目的是"限制同时执行的任务数",那正确做法是用 `Semaphore`、限流器或固定大小的资源池,而不是把虚拟线程塞进固定池——后者会让虚拟线程失去可扩展性。 错误示范与正确思路: ```java // 反例:用固定大小的池“复用”虚拟线程,等于自缚手脚 // 注意:这是反例,不要在生产使用 ExecutorService wrong = Executors.newFixedThreadPool(8, Thread.ofVirtual().factory()); // 正解一:每个任务一个虚拟线程 ExecutorService right = Executors.newVirtualThreadPerTaskExecutor(); // 正解二:若确实要限流,用信号量显式表达并发上限 // java.util.concurrent.Semaphore permits = new Semaphore(64); ``` **适用边界**:`newVirtualThreadPerTaskExecutor()` 本身不做并发上限控制,如果你的下游(数据库、第三方接口)无法承受高并发,必须在应用层加限流,否则会把压力直接传导给下游。 ## 四、常见误区与坑 ### Q:虚拟线程适合 CPU 密集型任务吗? A:结论先行——**不适合**。虚拟线程的收益来自"阻塞时让出载体线程",CPU 密集型任务几乎不阻塞,无法让出,收益趋近于零,还可能因为额外的调度与挂载开销而变差。 判断方法很简单:问自己"这段代码的时间主要花在等待,还是花在计算?" - 主要花在等待(网络、磁盘、数据库)→ 虚拟线程收益明显。 - 主要花在计算(加解密、压缩、复杂算法、大量内存计算)→ 用平台线程池,或 `parallelStream()`、`ForkJoinPool` 做**数据并行**。 需要澄清一个常见误解:**虚拟线程解决的是并发度问题,不是并行度问题**。它能让你同时"挂着"更多任务,但一个 CPU 核心同一时刻只能执行一个线程的指令。CPU 密集任务真正需要的是把核心喂满,这属于并行计算范畴。 ### Q:为什么说 ThreadLocal 在虚拟线程下要慎用?"虚拟线程默认不支持 ThreadLocal"这个说法对吗? A:结论先行——需要澄清:**JDK 21 最终版本的虚拟线程是支持 `ThreadLocal`(以及 `InheritableThreadLocal`)的**,这是为了兼容大量既有库。真正要注意的不是"不支持",而是"**数量放大 + 复用假设失效**"这两点。关于不同 JDK 版本的具体行为,**需结合所用 JDK 版本确认**。 先纠正版本细节:在 JDK 19、20 的**预览**阶段,曾允许创建"不支持 ThreadLocal 的虚拟线程";到 **JDK 21(JEP 444 定稿)**,虚拟线程改为**总是支持** thread-local 变量,不再提供"禁用 ThreadLocal"的选项(以 JEP 444 的描述为准,需结合所用 JDK 版本确认)。 那为什么还要慎用?两个真实问题: 1. **内存放大**:平台线程池通常只有几十到几百个线程,每个线程一份 `ThreadLocal` 副本,成本可控。虚拟线程可达数十万上百万个,如果每个虚拟线程都持有一份较重的 `ThreadLocal` 值(比如一个缓冲区、一个连接包装对象),内存会被成倍放大。 2. **"缓存复用"假设失效**:很多人用 `ThreadLocal` 做线程级缓存,依赖"线程被池化、缓存被复用"。虚拟线程**每个任务一个新线程**,缓存不再跨任务复用,于是退化成"每个任务都重新初始化一次",表现为缓存命中率骤降、GC 压力上升。这是个很隐蔽的坑,因为它不报错,只是性能悄悄退化。 JDK 提供了排查手段:设置系统属性 `jdk.traceVirtualThreadLocals` 后,虚拟线程在设置 thread-local 变量时会打印栈追踪,便于找出滥用的位置(该属性为诊断用途,具体行为需结合版本确认)。 替代方向是 **ScopedValue(作用域值)**:它是为"有明确作用域、随作用域自动失效"的上下文传递而设计的,正适合请求上下文这类场景,且避免了 `InheritableThreadLocal` 的传播陷阱。ScopedValue 的正式化版本与 API 形态演进较快,**以所用 JDK 版本为准**。 ```java // 目标:用 ThreadLocal 做线程级缓存——在虚拟线程下要警惕这种做法 private static final ThreadLocal<byte[]> BUFFER = ThreadLocal.withInitial(() -> new byte[64 * 1024]); // 每个虚拟线程都会各自创建一份 64KB 缓冲;虚拟线程数量一多,内存放大明显。 // 更稳妥的做法:把可复用对象显式传递,或使用 ScopedValue / 池化到有界资源里。 ``` **适用与不适用**:`ThreadLocal` 并非不能用,而是不要用它承载"昂贵且需要跨任务复用"的状态;请求级只读上下文更推荐 ScopedValue;纯函数式的参数传递最稳妥。 ### Q:`synchronized` 导致的 pinning(固定)问题是什么?后续版本改了吗? A:结论先行——**在 JDK 21 上**,如果虚拟线程在 `synchronized` 方法/代码块内发生阻塞,它无法卸载,会被"固定(pin)"在载体线程上,从而丧失虚拟线程的核心优势;较新的 JDK 版本已大幅放宽这一限制,但**具体改进的版本与覆盖范围需结合所用 JDK 版本确认**。 为什么 JDK 21 会 pin?`synchronized` 基于**监视器(monitor)**实现,JVM 在 JDK 21 上记录的是"**哪个平台线程(载体线程)持有监视器**",而不是"哪个虚拟线程持有"。因此虚拟线程在持有监视器期间不能卸载,否则监视器的归属就说不清了。结果就是:进入 `synchronized` 后一旦阻塞(如 `socket.read()`、`Object.wait()`),载体线程会被一起占住。 ```java // JDK 21 上的典型 pinning 场景:synchronized 里做阻塞 IO // 注意:这是需要排查的反例 synchronized byte[] fetch() throws IOException { // 这里若发生阻塞,虚拟线程无法卸载,载体线程被占用 return socket.getInputStream().readAllBytes(); } ``` pinning 的危害不是"单次变慢",而是**载体线程被耗尽**:默认载体线程数不多,若大量虚拟线程同时在 `synchronized` 里阻塞,载体线程被占满,其他本可运行的虚拟线程也得不到调度,严重时表现为整体"卡死"。历史上已有生产事故报告(如 Netflix 2024 年公开的虚拟线程死锁复盘),根因正是第三方库或 JDK 内部的 `synchronized` 隐藏了 pinning。 改进与排查: - **改进方向**:后续 JDK 通过让虚拟线程能够"独立于载体线程持有监视器"来消除大部分 `synchronized` pinning(对应 JDK 24 的 JEP 491 "Synchronize Virtual Threads without Pinning",其状态与生效版本**需结合所用 JDK 版本确认**)。需要注意:**即使改进后,仍可能残留少数 pinning 场景**(如某些本地方法/原生帧、类加载相关路径等),所以排查手段依然要留在工具箱里。 - **排查手段**:用 JFR 关注与虚拟线程相关的固定事件(如 `jdk.VirtualThreadPinned`),这类事件有助于定位"在哪个栈上被 pin"。事件名与字段在不同版本可能变化,**以所用版本为准**。 **缓解策略**(在不能升级 JDK 时尤其有用): 1. 把热点路径上的 `synchronized` 替换为 `ReentrantLock`——后者基于 `LockSupport`,虚拟线程阻塞时可正常卸载。 2. 缩小 `synchronized` 临界区,尤其**不要在临界区里做 IO**。 3. 排查依赖栈:`synchronized` 往往藏在第三方库甚至 JDK 内部(例如部分并发容器的内部实现),需要用 pinning 事件定位。 ### Q:为什么池化资源(连接池、限流器、线程数假设)在虚拟线程下要重新评估? A:结论先行——虚拟线程把"服务端可同时挂起的请求数"抬高了,原本按几十上百个平台线程设计的**下游资源上限**(数据库连接池、HTTP 连接池、文件描述符、限流阈值、下游服务容量)会立刻成为新的瓶颈。 原来的系统里,线程池大小本身就是一道"隐形限流":最多 200 个平台线程,就最多 200 个请求在跑,数据库连接池配 50 也相安无事。切到虚拟线程后,同时运行的请求可达成千上万,如果连接池还是 50,就会出现大量请求卡在"等连接"上——**瓶颈从线程转移到了连接池**,而且是排队超时,画面很像"服务变慢了",容易被误判。 ```java // 目标:不要让“等连接”把虚拟线程的优势吃光 // 连接池大小、获取连接超时、下游限流阈值都要重新评估并显式配置。 // 伪代码示意(以 JDBC 连接池为例): // HikariConfig cfg = new HikariConfig(); // cfg.setMaximumPoolSize(...); // 不能拍脑袋,要按数据库容量压测 // cfg.setConnectionTimeout(...); // 明确“等不到连接”的行为,便于快速失败 ``` **排查思路**:迁移前后重点监控"获取连接等待时间""连接池活跃数/等待数""下游接口 P99""文件描述符数量",而不是只盯线程数——因为线程数不再是那个卡点。 ## 五、迁移建议 ### Q:存量应用如何渐进地迁移到虚拟线程? A:结论先行——**先隔离、再替换、后压测**:从 IO 密集的边界(如 HTTP 调用、数据库访问)切入,用 `newVirtualThreadPerTaskExecutor()` 替换原来的线程池,配合压测与 pinning/资源排查,确认无误后再逐步推广;不要一次性全量切换。 分步建议: 1. **评估**:先确认 JDK 版本(至少 21),并梳理代码与依赖中阻塞 IO、`synchronized`、`ThreadLocal`、连接池的使用。JDK 版本决定了 pinning 与 API 行为,务必**结合所用 JDK 版本确认**。 2. **隔离**:只把"每个请求独立、以阻塞等待为主"的路径切到虚拟线程执行器,CPU 密集的批处理仍走平台线程池。 3. **替换**: ```java // 变更前(示意) // ExecutorService pool = Executors.newFixedThreadPool(200); // 变更后 ExecutorService pool = Executors.newVirtualThreadPerTaskExecutor(); ``` 尽量保持 `ExecutorService` 接口不变,减少对上层代码的改动。 4. **加固**:给下游加限流(`Semaphore` 等),重新评估连接池;清理 `ThreadLocal` 滥用;把热点 `synchronized` 换成 `ReentrantLock`。 5. **验证**:压测时同时观察吞吐、P99、载体线程利用率、pinning 事件、连接池等待、文件描述符;特别关注"看似变慢"的排队类问题。 6. **回滚预案**:保留"切回平台线程池"的开关,确保出问题能快速回退。 **迁移不适用/要额外小心的场景**:大量原生方法(JNI)调用、依赖对线程身份/线程本地存储有强假设的框架、以及强 CPU 密集的批处理。 ## 小结 - 本质:平台线程 1:1 映射内核线程;虚拟线程由 JVM 以 M:N 调度到少量载体线程(默认调度器基于 ForkJoinPool)。 - 价值:让"一个请求一个线程"的同步阻塞写法在高并发 IO 场景下可扩展,抬高的是并发度,不是单请求速度。 - 机制:基于 Continuation 在阻塞点挂起/恢复,把栈帧搬到堆上并让出载体线程;`LockSupport`、JUC、网络 IO 已对虚拟线程友好。 - 创建:`Thread.startVirtualThread`、`Thread.ofVirtual()`、`Executors.newVirtualThreadPerTaskExecutor()`;**不要池化虚拟线程**。 - 坑:CPU 密集不适用;`ThreadLocal` 会放大内存且缓存复用假设失效(JDK 21 实际是**支持** ThreadLocal 的);JDK 21 上 `synchronized` 会导致 pinning,较新版本已放宽(**需结合版本确认**,且仍可能有残留);连接池/限流等下游资源必须重新评估。 - 迁移:先隔离、再替换、后压测,保留回滚开关。 ## 思考题 1. 为什么说虚拟线程"提高的是并发度而不是并行度"?请结合一个 CPU 密集型任务说明。 2. 一个接口在切换到虚拟线程后吞吐不升反降,你会按什么顺序排查?请至少列出三个怀疑对象。 3. `ThreadLocal` 在虚拟线程下"缓存失效"这个坑为什么不会报错?你会怎样提前发现它? 4. JDK 21 上,把 `synchronized` 换成 `ReentrantLock` 为什么能缓解 pinning? 5. 如果数据库连接池仍是 50,把线程池换成 `newVirtualThreadPerTaskExecutor()` 后,瓶颈会出现在哪里?如何观察?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入