虚拟线程开了没提速,Java后端先改这4处
订单详情接口卡在 900 QPS,CPU 才 20%,Tomcat 线程池先满了。把
spring.threads.virtual.enabled打开,QPS 冲到 1200 又不动了,P99 从 300ms 拉到 3 秒,下游风控开始回 429。虚拟线程不是开关一开就变快,它只拆掉了「线程不够」这一堵墙,后面还有三堵等着你。这篇把四堵墙一个个拆开,代码能直接跑。
一、虚拟线程没提速,问题到底出在哪
结论先放这:虚拟线程只让你「等得起」,不负责让下游「扛得住」。
先把场景说清楚。一个订单详情接口,一次请求干三件事:查风控(远程调用,150ms)、查订单(MySQL 主键点查,5ms)、拼装返回(45ms)。平均 200ms,其中 150ms 纯粹在等网络。
平台线程模式下,Tomcat 默认 200 个工作线程。每个请求占一个线程 200ms,理论上限就是 200 / 0.2 = 1000 QPS,实测 900 左右。CPU 只用了 20%,因为 200 个线程里有 150ms 是在 socketRead 上干等,内核线程睡着,CPU 无事可做。
这不是「算得慢」,是「线程不够用」。虚拟线程正好治这个:等待的时候把底层线程让出来。所以打开开关后 QPS 上去了,到 1200。
然后就卡住了。为啥?
因为线程不再是瓶颈,下一个瓶颈浮出来了。数据库连接池这次不是问题:1200 QPS × 5ms = 6 个连接同时在用,Hikari 给了 10 个,够。真正撑不住的是下游风控,它单实例稳定扛 1200 QPS 左右,你正好把它打满,多出来的请求全变成 429。它一开始限流,你的线程就堵在等响应上,P99 从 300ms 飙到 3 秒。
这里有件事值得记住:不是每个连接池都会成为瓶颈。瓶颈永远出现在「容量最小、又没人管」的那一环,可能是一次第三方调用,也可能是对方网关的限流阈值。
这就是虚拟线程最反直觉的地方:它把你的并发能力放大了,也把压力原封不动传给了下游。
四堵墙,按撞上的顺序排:
| 墙 | 典型表现 | 怎么确认 |
|---|---|---|
| 下游容量(DB 连接池、第三方配额、HTTP 连接池) | QPS 涨一点就停,下游 429 / 超时 | 看连接池 active 数、下游错误率 |
@Async 执行器 |
异步任务把下游打爆,堆内存上涨 | 看 spring.task.execution 有没有配上限 |
synchronized 钉住载体线程 |
开了虚拟线程反而更慢 | -Djdk.tracePinnedThreads=full(JDK 21)或 JFR |
| 可观测性和生命周期 | 日志丢 traceId、定时任务把 JVM 弄退出 | 线程 dump、spring.main.keep-alive |
下一节说清楚虚拟线程到底是怎么让出线程的,你才知道为什么 synchronized 会成为例外。
二、底层原理:虚拟线程怎么“让出”线程
结论:虚拟线程是 JVM 自己调度的「任务」,只有在 JDK 认识的阻塞点上才会交出底层线程。
平台线程和虚拟线程的区别
平台线程是 1:1 包着操作系统线程的。创建一个平台线程,操作系统就得给它分配内核线程和栈空间,默认栈预留 1MB。创建贵、切换贵、数量上限低,200 个线程等网络,就是 200 个内核线程陪着一起睡。
虚拟线程是 JVM 在用户态实现的。它的栈放在 Java 堆上,用多少长多少,不预先占 1MB。你开一万个虚拟线程,JVM 也只是多分配一些对象。
真正干活的是「载体线程」(carrier thread)。载体线程就是平台线程,数量默认等于 CPU 核数,由 JVM 内部一个 ForkJoinPool 管理。
mount 和 unmount:让出的那一刻发生了什么
虚拟线程跑起来的时候,会被「挂载」到一个载体线程上执行。它一旦碰到阻塞操作,JVM 做两件事:
- 把这个虚拟线程的调用栈从载体线程上摘下来(unmount),存回堆里;
- 载体线程立刻去跑别的虚拟线程。
等阻塞结束,虚拟线程重新排队,等一个空闲载体线程再挂载上去接着跑(mount)。
拿餐厅打个比方。平台线程模式是:服务员带客人到桌边,客人看菜单看十分钟,服务员就站旁边等十分钟,别的客人没人管。虚拟线程模式是:客人说「我先看看」,服务员转身去招呼其他桌,客人想好了举手,谁空谁过来。
所以 4 个核的机器,8 个载体线程,就能撑住上万个同时在等 IO 的请求。前提是——它们真的在「等 IO」。
为什么 synchronized 是例外
关键在于「JDK 认识的阻塞点」。Socket 读写、文件 IO、Thread.sleep、LockSupport.park、阻塞队列、ReentrantLock,这些 JDK 都知道怎么让虚拟线程下车。
synchronized 在 JDK 21 上不行。虚拟线程在 synchronized 块里阻塞时,JVM 没法安全地把栈摘下来,只能让虚拟线程死死钉在载体线程上。这叫 pinning(钉住)。你开了 5000 个虚拟线程,只要有一批卡在 synchronized 里,8 个载体线程全被占死,整个应用直接停摆——比平台线程还惨,因为平台线程至少还有 200 个。
JDK 24 的 JEP 491 把这个问题解决了:虚拟线程在 synchronized 里阻塞时也能释放载体线程。所以 JDK 24 之后 pinning 基本只剩两种情况:JNI 调用里回调 Java 再阻塞、类初始化时的锁。日常业务代码很难碰到。
如果你还卡在 JDK 21,遇到老代码里成片的 synchronized,要么换 ReentrantLock,要么先别开虚拟线程。
Spring Boot 打开开关后到底改了什么
spring.threads.virtual.enabled=true 不是一句空话,Boot 在启动时替换了好几处:
- Web 请求处理:Tomcat 的请求不再从固定大小的线程池里取线程,而是每个请求一个虚拟线程。
server.tomcat.threads.max这时已经是摆设。 @Async执行器:默认的ThreadPoolTaskExecutor换成SimpleAsyncTaskExecutor,每个任务开一个虚拟线程。@Scheduled调度器:换成SimpleAsyncTaskScheduler,同样忽略池大小配置。- 线程池配置失效:
spring.task.execution.pool.*、spring.task.scheduling.pool.size这些参数不再生效,因为虚拟线程不归这些池子管。
最后一条是很多人踩坑的起点。你原来靠 core-size: 8 / queue-capacity: 100 控制的并发上限,打开开关之后一夜之间消失了。
还有一个坑藏在细节里:虚拟线程是守护线程。JVM 在所有线程都是守护线程时会退出。如果你的应用主要靠 @Scheduled 撑着,调度线程变成守护线程后,主线程一结束 JVM 就退出了。官方给的解法是加一行 spring.main.keep-alive=true。
三、实战:一个能跑起来的压测项目
光讲原理没意义,搭个项目自己压一遍。目标:同一个接口,先看平台线程的吞吐,再看虚拟线程的吞吐,再看加了并发上限之后的表现。
项目结构
virtual-thread-demo
├── pom.xml
└── src/main
├── java/com/example/vtdemo
│ ├── VtDemoApplication.java
│ ├── ThreadInfoController.java
│ ├── config/AsyncConfig.java
│ ├── config/MdcTaskDecorator.java
│ └── order
│ ├── AsyncReportService.java
│ ├── Order.java
│ ├── OrderController.java
│ ├── OrderRepository.java
│ ├── OrderService.java
│ └── OrderView.java
└── resources
├── application.yml
├── schema.sql
└── data.sql
pom.xml
src/main/resources 同级,项目根目录:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>4.1.2</version>
<relativePath/>
</parent>
<groupId>com.example</groupId>
<artifactId>virtual-thread-demo</artifactId>
<version>1.0.0</version>
<name>virtual-thread-demo</name>
<properties>
<java.version>21</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webmvc</artifactId>
<version>4.1.2</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
<version>4.1.2</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
<version>4.1.2</version>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>2.5.252</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>4.1.2</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>4.1.2</version>
</plugin>
</plugins>
</build>
</project>
注意这里用的是 spring-boot-starter-webmvc。spring-boot-starter-web 在这个版本里已经被标记为废弃(描述里写着 deprecated in favor of spring-boot-starter-webmvc),两个都能跑,新项目直接用新的,省得以后升级时再改。
application.yml
server:
port: 8080
spring:
application:
name: virtual-thread-demo
threads:
virtual:
enabled: true
main:
keep-alive: true
datasource:
url: jdbc:h2:mem:demo;DB_CLOSE_DELAY=-1
driver-class-name: org.h2.Driver
username: sa
password: ""
hikari:
maximum-pool-size: 10
minimum-idle: 10
connection-timeout: 1000
sql:
init:
mode: always
management:
endpoints:
web:
exposure:
include: health,metrics,threaddump
spring.threads.virtual.enabled 是总开关,spring.main.keep-alive 防 JVM 提前退出。连接池故意只给 10 个,后面讲踩坑时你会看到它什么时候才变成瓶颈。connection-timeout 设成 1 秒,是为了让排队现象快速暴露,而不是等 30 秒超时。
建表和初始数据
src/main/resources/schema.sql:
DROP TABLE IF EXISTS orders;
CREATE TABLE orders (
id BIGINT NOT NULL PRIMARY KEY,
user_id BIGINT NOT NULL,
amount DECIMAL(10, 2) NOT NULL,
status VARCHAR(16) NOT NULL
);
src/main/resources/data.sql:
INSERT INTO orders (id, user_id, amount, status) VALUES (1, 1001, 199.00, 'PAID');
INSERT INTO orders (id, user_id, amount, status) VALUES (2, 1002, 299.50, 'CREATED');
INSERT INTO orders (id, user_id, amount, status) VALUES (3, 1003, 88.80, 'PAID');
启动类
src/main/java/com/example/vtdemo/VtDemoApplication.java:
package com.example.vtdemo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class VtDemoApplication {
public static void main(String[] args) {
SpringApplication.run(VtDemoApplication.class, args);
}
}
订单模型和查询
src/main/java/com/example/vtdemo/order/Order.java:
package com.example.vtdemo.order;
import java.math.BigDecimal;
public record Order(Long id, Long userId, BigDecimal amount, String status) {
}
src/main/java/com/example/vtdemo/order/OrderView.java:
package com.example.vtdemo.order;
import java.math.BigDecimal;
public record OrderView(Long id, Long userId, BigDecimal amount, String status) {
}
src/main/java/com/example/vtdemo/order/OrderRepository.java:
package com.example.vtdemo.order;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import java.util.Optional;
@Repository
public class OrderRepository {
private static final RowMapper<Order> ROW_MAPPER = (rs, rowNum) -> new Order(
rs.getLong("id"),
rs.getLong("user_id"),
rs.getBigDecimal("amount"),
rs.getString("status")
);
private final JdbcTemplate jdbcTemplate;
public OrderRepository(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
public Optional<Order> findById(long id) {
return jdbcTemplate
.query("SELECT id, user_id, amount, status FROM orders WHERE id = ?", ROW_MAPPER, id)
.stream()
.findFirst();
}
}
业务层:模拟那个 200ms 的接口
src/main/java/com/example/vtdemo/order/OrderService.java:
package com.example.vtdemo.order;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
@Service
public class OrderService {
private static final Logger log = LoggerFactory.getLogger(OrderService.class);
private final OrderRepository orderRepository;
public OrderService(OrderRepository orderRepository) {
this.orderRepository = orderRepository;
}
public OrderView query(long id) {
// 模拟 150ms 的风控远程调用,真实项目里这里是 RestClient 或 Feign
sleep(150);
Order order = orderRepository.findById(id)
.orElseThrow(() -> new IllegalArgumentException("订单不存在: " + id));
// 模拟 45ms 的组装和序列化开销
sleep(45);
Thread current = Thread.currentThread();
log.info("订单查询完成, id={}, virtual={}, thread={}", id, current.isVirtual(), current.getName());
return new OrderView(order.id(), order.userId(), order.amount(), order.status());
}
private void sleep(long millis) {
try {
Thread.sleep(millis);
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
throw new IllegalStateException("任务被中断", ex);
}
}
}
Thread.sleep 在这里是替身。真实项目里换成 RestClient 调风控、JdbcTemplate 查库都行,阻塞行为一样,虚拟线程的处理方式也一样。
控制器:同步接口和异步接口
src/main/java/com/example/vtdemo/order/OrderController.java:
package com.example.vtdemo.order;
import org.slf4j.MDC;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
@RestController
@RequestMapping("/api/orders")
public class OrderController {
private final OrderService orderService;
private final AsyncReportService asyncReportService;
public OrderController(OrderService orderService, AsyncReportService asyncReportService) {
this.orderService = orderService;
this.asyncReportService = asyncReportService;
}
@GetMapping("/{id}")
public OrderView query(@PathVariable long id) {
return orderService.query(id);
}
@GetMapping("/{id}/report")
public CompletableFuture<String> report(@PathVariable long id) {
MDC.put("traceId", UUID.randomUUID().toString().substring(0, 8));
try {
return asyncReportService.buildReport(id);
} finally {
MDC.remove("traceId");
}
}
}
再加一个专门看线程信息的控制器,路径单独放,避免和 /{id} 抢路由。
src/main/java/com/example/vtdemo/ThreadInfoController.java:
package com.example.vtdemo;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
@RestController
public class ThreadInfoController {
@GetMapping("/api/thread-info")
public Map<String, Object> threadInfo() {
Thread current = Thread.currentThread();
return Map.of(
"name", current.getName(),
"virtual", current.isVirtual(),
"daemon", current.isDaemon()
);
}
}
开了虚拟线程之后,这个接口返回的 virtual 是 true,name 里带 VirtualThread。如果还是 false,说明开关没生效或者被别的配置覆盖了。
异步执行的配置:并发上限和 MDC 传递
src/main/java/com/example/vtdemo/config/MdcTaskDecorator.java:
package com.example.vtdemo.config;
import org.slf4j.MDC;
import org.springframework.core.task.TaskDecorator;
import java.util.Map;
public class MdcTaskDecorator implements TaskDecorator {
@Override
public Runnable decorate(Runnable runnable) {
// decorate 在提交任务的线程里执行,这里能拿到调用方的 MDC
Map<String, String> context = MDC.getCopyOfContextMap();
return () -> {
if (context != null) {
MDC.setContextMap(context);
}
try {
runnable.run();
} finally {
MDC.clear();
}
};
}
}
src/main/java/com/example/vtdemo/config/AsyncConfig.java:
package com.example.vtdemo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.scheduling.annotation.EnableAsync;
@Configuration
@EnableAsync
public class AsyncConfig {
@Bean
public AsyncTaskExecutor applicationTaskExecutor() {
SimpleAsyncTaskExecutor executor = new SimpleAsyncTaskExecutor("vt-async-");
executor.setVirtualThreads(true);
executor.setConcurrencyLimit(50);
executor.setRejectTasksWhenLimitReached(true);
executor.setTaskDecorator(new MdcTaskDecorator());
return executor;
}
}
这几行是全篇最值钱的配置:
setVirtualThreads(true):每个任务一个虚拟线程。setConcurrencyLimit(50):同时在跑的任务最多 50 个,多的拒绝。不加这个,虚拟线程默认不限并发,一秒能给你开十万个。setRejectTasksWhenLimitReached(true):超限直接抛TaskRejectedException,快速失败,而不是无限排队把堆撑爆。setTaskDecorator(...):把调用方的 MDC 带进异步线程,日志里的 traceId 才不会断。
定义了 AsyncTaskExecutor 这个 Bean 之后,Boot 的自动配置会让位,spring.task.execution.* 那些配置项也就不再生效了——上限由你写的 concurrencyLimit 决定。
异步服务
src/main/java/com/example/vtdemo/order/AsyncReportService.java:
package com.example.vtdemo.order;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;
@Service
public class AsyncReportService {
private static final Logger log = LoggerFactory.getLogger(AsyncReportService.class);
@Async
public CompletableFuture<String> buildReport(long orderId) {
try {
Thread.sleep(300);
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
throw new IllegalStateException("报表任务被中断", ex);
}
log.info("报表生成完成, orderId={}, virtual={}", orderId, Thread.currentThread().isVirtual());
return CompletableFuture.completedFuture("report-" + orderId);
}
}
日志里会同时出现 vt-async- 前缀和 virtual=true,traceId 也在——三件事一次验证完。
跑起来压一遍
启动:
mvn spring-boot:run
先确认线程类型:
curl -s http://localhost:8080/api/thread-info
返回 "virtual":true 就对了。
压测用 200 并发打 2000 个请求,记录总耗时:
time seq 1 2000 | xargs -P 200 -I{} curl -s -o /dev/null http://localhost:8080/api/orders/1
再把 application.yml 里的 spring.threads.virtual.enabled 改成 false,重启,跑同一条命令。对比两次的总耗时,比例就是虚拟线程在这个场景里给你的收益。接口本身 180ms 是睡出来的,所以这个对比只反映「线程是否成为瓶颈」,不代表真实业务能提速这么多。
诊断:线程到底卡在哪
看虚拟线程的完整线程栈:
jcmd <pid> Thread.dump_to_file -format=json /tmp/threads.json
这个 JSON 里包含所有虚拟线程,数量可能是几万个,jstack 看不到它们。
抓 pinning(JDK 21):
java -Djdk.tracePinnedThreads=full -jar target/virtual-thread-demo-1.0.0.jar
只要虚拟线程在 synchronized 里阻塞,控制台就会打完整堆栈,附带 reason=monitor。JDK 24 之后这个参数已经不需要了,因为 synchronized 不再钉住线程,改成看 jdk.VirtualThreadPinned 事件:
jcmd <pid> JFR.start name=vt settings=profile duration=60s filename=/tmp/vt.jfr
用 JDK Mission Control 打开 /tmp/vt.jfr,搜 VirtualThreadPinned 事件。
四、踩坑:四个真实坑
坑一:连接池不调,虚拟线程白开
虚拟线程不会让数据库多出一个连接。
每个请求占数据库连接的时间没变,池子大小没变,数据库侧的吞吐上限就没变。虚拟线程能做的是让请求「排队等连接」而不是「占着线程等连接」,所以现象会从「Tomcat 线程池满」变成「Hikari 连接超时」。
池子大小别拍脑袋。粗略算:连接数 ≈ 目标 QPS × 单次持有时间(秒)。1200 QPS × 0.02s = 24 个连接,给 10 个肯定不够。但也别一把调到 200,数据库的连接数、CPU、锁竞争都有上限,MySQL 单机超过一两百个活跃连接,上下文切换的损耗比收益大。
正确做法是先看 HikariPool 的 active 和 pending 指标,pending 长期大于 0 才是真的不够。
坑二:@Async 变成了不限并发的执行器
这是开虚拟线程后最容易炸的地方。
平台线程模式下,@Async 用的是 ThreadPoolTaskExecutor,默认核心 8 个线程、队列容量 Integer.MAX_VALUE。任务多了就排队,虽然延迟高,但不会瞬间把下游打死。
开了虚拟线程,执行器换成 SimpleAsyncTaskExecutor,默认 concurrencyLimit = -1,也就是不限并发。来一万个任务就开一万个虚拟线程,同时打到下游。下游扛不住,你的任务全超时;虚拟线程的栈虽然小,一万个堆栈同时存在也不是免费的。
两种解法:
- 简单场景,一行配置:
spring.task.execution.simple.concurrency-limit=50,需要快速失败再加spring.task.execution.simple.reject-tasks-when-limit-reached=true。 - 要传 MDC 或自定义线程名,就按上面的
AsyncConfig自己定义 Bean,把上限写死在代码里。
记住一句话:虚拟线程负责「能开很多」,限流负责「该开多少」。这两件事不能互相替代。
坑三:JDK 21 上 synchronized 把你的吞吐打回去了
老代码里到处是 synchronized 的 DAO、单例工具类、老版本 HTTP 客户端。JDK 21 上这些地方会 pin 住载体线程。
现象很典型:并发一上来,QPS 不升反降,CPU 上不去,线程 dump 里几千个虚拟线程全是 BLOCKED,载体线程只有 8 个,每个都被钉住。
处理顺序:先开 -Djdk.tracePinnedThreads=full 找出钉住的位置;能改的改成 ReentrantLock;改不动的(第三方 jar)评估能不能升 JDK 24+。升不上去又改不动,那就先别开虚拟线程,这不是配置能绕过去的问题。
坑四:日志丢 traceId,定时任务消失
两个小问题,排查起来能耗一下午。
MDC 存在 ThreadLocal 里。@Async 换了线程,ThreadLocal 不会跟过去,日志里的 traceId 直接变成空。解法就是上面的 MdcTaskDecorator,提交任务时把 MDC 快照带走。
定时任务的问题更隐蔽。虚拟线程是守护线程,@Scheduled 的调度线程也变成守护线程后,如果 JVM 里没有非守护线程撑着,主线程一结束进程就退了。表现是「本地跑着好好的,打包部署后启动完就退出,日志没有任何异常」。加 spring.main.keep-alive=true。
顺便说一句,jvm.threads.live 这个指标不统计虚拟线程,看着一直是个位数别慌。要看虚拟线程数量,用 jcmd Thread.dump_to_file,或者 JFR。
五、性能对比:什么时候该开,什么时候别碰
结论:虚拟线程是 IO 密集型应用的吞吐工具,不是通用加速器。
| 维度 | 平台线程 | 虚拟线程 |
|---|---|---|
| 每个线程的内存成本 | 默认预留 1MB 栈 | 栈在堆上按需增长,通常几 KB 起 |
| 阻塞时的代价 | 内核线程陪着等 | 释放载体线程,别人接着跑 |
| 并发上限来源 | 线程池大小 | 下游容量 + 内存 + 你自己设的限流 |
| CPU 密集任务 | 正常 | 没有收益,甚至因为调度多一层略慢 |
| 调试难度 | jstack 一把梭 |
需要 jcmd / JFR,工具链要跟上 |
适合开的场景:
- 接口以等待为主:调下游 HTTP、查库、读 Redis、发消息,CPU 利用率长期低于 40%。
- 并发量远超 CPU 核数,且请求之间互不依赖。
- 已经有明确的限流手段(连接池、信号量、网关限流),知道自己能打多少。
别开的场景:
- 计算密集:加解密、图片处理、复杂规则计算。核数不变,开多少线程都一样。
- 大量
synchronized且短时间升不了 JDK 24。 - 已经在用 WebFlux 且跑得挺好。响应式已经把线程占用压到极低,换虚拟线程属于折腾。
- 下游没有任何配额保护,你也不知道它能扛多少。先做限流,再谈虚拟线程。
还有一个常被忽略的成本:可观测性。几千个虚拟线程的 dump 是好几百 MB,传统的「看线程数报警」全部失效。团队得先把 JFR、指标、结构化日志补齐,再上虚拟线程。
六、总结
虚拟线程解决的是「线程太贵,等不起」的问题,不是「系统慢」的问题。
打开开关只要一行配置,真正的工作在开关之外:算清楚下游能给多少并发,把连接池和限流配到匹配,把 synchronized 的老账翻出来,把 MDC 和监控补齐。这四件事做完,虚拟线程才会给你应有的回报。
判断要不要上,问自己一个问题:你的接口时间花在等,还是花在算? 答案在等,就值得试;答案在算,加机器比加线程有用。
文 / 会编程的吕洞宾