Java 虚拟线程别乱用:I/O 密集型服务的线程模型与并发度计算
一句话结论:虚拟线程降低的是"等待的成本",不是"下游的容量"。不会算并发度,虚拟线程只会让你更快地把数据库打挂。
版本基线:Java 21 / Spring Boot 3.2+;JDK 17 可用平台线程方案,但无虚拟线程。
1. 线程池 200,为什么 QPS 上不去?
一个查询服务,Tomcat maxThreads=200,平均 RT 120ms:
text
理论吞吐 = 200 / 0.12 ≈ 1,666 QPS
按 70% 利用率 ≈ 1,166 QPS
如果目标 QPS 是 3,000,只有三条路:
- 降低 RT:缓存、索引、减少远程调用;
- 提高并发度:更多线程、异步、虚拟线程、扩容;
- 限流:承认容量不够,保护系统。
很多团队直接选 2,把线程池从 200 调到 500。结果:
- 平台线程栈默认 1MB,500 线程仅栈就占约 500MB;
- 上下文切换增加,CPU 花在调度而不是业务;
- 每个线程都去抢 Hikari 连接,连接池 pending 飙升;
- DB 并发变高,慢查询更多,RT 更长;
- 为了维持吞吐,又加线程......形成负反馈。
线程不是越多越好,线程数应该匹配"同时等待的数量",并被下游容量约束。
2. 平台线程 vs 虚拟线程
2.1 平台线程的成本
| 成本项 | 量级 | 说明 |
|---|---|---|
| 栈内存 | 默认 1MB(-Xss) |
1000 线程约 1GB 虚拟地址/物理占用 |
| 创建/销毁 | 微秒~毫秒 | 频繁创建代价高 |
| 上下文切换 | 微秒级 | 线程多时调度开销明显 |
| 内核调度 | 1:1 | 每个平台线程对应一个 OS 线程 |
2.2 虚拟线程的运行模型
#mermaid-svg-32UVI1QRjCBfi8Zc{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-32UVI1QRjCBfi8Zc .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-32UVI1QRjCBfi8Zc .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-32UVI1QRjCBfi8Zc .error-icon{fill:#552222;}#mermaid-svg-32UVI1QRjCBfi8Zc .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-32UVI1QRjCBfi8Zc .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-32UVI1QRjCBfi8Zc .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-32UVI1QRjCBfi8Zc .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-32UVI1QRjCBfi8Zc .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-32UVI1QRjCBfi8Zc .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-32UVI1QRjCBfi8Zc .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-32UVI1QRjCBfi8Zc .marker{fill:#333333;stroke:#333333;}#mermaid-svg-32UVI1QRjCBfi8Zc .marker.cross{stroke:#333333;}#mermaid-svg-32UVI1QRjCBfi8Zc svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-32UVI1QRjCBfi8Zc p{margin:0;}#mermaid-svg-32UVI1QRjCBfi8Zc .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-32UVI1QRjCBfi8Zc .cluster-label text{fill:#333;}#mermaid-svg-32UVI1QRjCBfi8Zc .cluster-label span{color:#333;}#mermaid-svg-32UVI1QRjCBfi8Zc .cluster-label span p{background-color:transparent;}#mermaid-svg-32UVI1QRjCBfi8Zc .label text,#mermaid-svg-32UVI1QRjCBfi8Zc span{fill:#333;color:#333;}#mermaid-svg-32UVI1QRjCBfi8Zc .node rect,#mermaid-svg-32UVI1QRjCBfi8Zc .node circle,#mermaid-svg-32UVI1QRjCBfi8Zc .node ellipse,#mermaid-svg-32UVI1QRjCBfi8Zc .node polygon,#mermaid-svg-32UVI1QRjCBfi8Zc .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-32UVI1QRjCBfi8Zc .rough-node .label text,#mermaid-svg-32UVI1QRjCBfi8Zc .node .label text,#mermaid-svg-32UVI1QRjCBfi8Zc .image-shape .label,#mermaid-svg-32UVI1QRjCBfi8Zc .icon-shape .label{text-anchor:middle;}#mermaid-svg-32UVI1QRjCBfi8Zc .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-32UVI1QRjCBfi8Zc .rough-node .label,#mermaid-svg-32UVI1QRjCBfi8Zc .node .label,#mermaid-svg-32UVI1QRjCBfi8Zc .image-shape .label,#mermaid-svg-32UVI1QRjCBfi8Zc .icon-shape .label{text-align:center;}#mermaid-svg-32UVI1QRjCBfi8Zc .node.clickable{cursor:pointer;}#mermaid-svg-32UVI1QRjCBfi8Zc .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-32UVI1QRjCBfi8Zc .arrowheadPath{fill:#333333;}#mermaid-svg-32UVI1QRjCBfi8Zc .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-32UVI1QRjCBfi8Zc .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-32UVI1QRjCBfi8Zc .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-32UVI1QRjCBfi8Zc .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-32UVI1QRjCBfi8Zc .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-32UVI1QRjCBfi8Zc .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-32UVI1QRjCBfi8Zc .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-32UVI1QRjCBfi8Zc .cluster text{fill:#333;}#mermaid-svg-32UVI1QRjCBfi8Zc .cluster span{color:#333;}#mermaid-svg-32UVI1QRjCBfi8Zc div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-32UVI1QRjCBfi8Zc .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-32UVI1QRjCBfi8Zc rect.text{fill:none;stroke-width:0;}#mermaid-svg-32UVI1QRjCBfi8Zc .icon-shape,#mermaid-svg-32UVI1QRjCBfi8Zc .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-32UVI1QRjCBfi8Zc .icon-shape p,#mermaid-svg-32UVI1QRjCBfi8Zc .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-32UVI1QRjCBfi8Zc .icon-shape rect,#mermaid-svg-32UVI1QRjCBfi8Zc .image-shape rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-32UVI1QRjCBfi8Zc .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-32UVI1QRjCBfi8Zc .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-32UVI1QRjCBfi8Zc :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 操作系统线程
载体线程(ForkJoinPool,数量≈CPU 核数)
虚拟线程(大量,JVM 管理)
阻塞时卸载
阻塞时卸载
阻塞时卸载
VT-1
等待 DB
VT-2
等待 Redis
VT-3
等待 RPC
VT-4
CPU 计算
Carrier-1
Carrier-2
Carrier-3
OS Thread-1
OS Thread-2
OS Thread-3
关键点:
- 虚拟线程是 JVM 调度的轻量线程,不是 OS 线程;
- 遇到 I/O 阻塞时,虚拟线程会从载体线程上 unmount,载体去跑其他虚拟线程;
- 阻塞结束后再 mount 回某个载体;
- 因此,等待不再长期占用 OS 线程,同样的内存可以承载更多并发。
但注意:虚拟线程不会让 DB 查询变快,也不会增加连接池大小。 它只是让"等待"更便宜,从而把瓶颈更早地暴露给下游。
3. 并发度怎么算:两个公式,一个上限
3.1 Little's Law
text
L = λ × W
L:需要的并发请求数λ:目标 QPSW:平均 RT(秒)
示例:目标 3,000 QPS,平均 RT 80ms:
text
L = 3000 × 0.08 = 240
考虑 P99 和突发,实际并发上限要留 2~3 倍余量,例如 500~700。但这不是让你无限开线程,而是告诉你:200 个平台线程在数学上就不够。
3.2 线程池经验公式
text
N_threads = N_cpu × U_cpu × (1 + W / C)
N_cpu:可用 CPU 核数(容器内注意 cgroup)U_cpu:目标 CPU 利用率(如 0.7)W/C:等待时间 / 计算时间
示例:8 核,目标 70%,W/C = 10:
text
N = 8 × 0.7 × 11 ≈ 62
如果 W/C = 50(大量 RPC 等待),N ≈ 285。但这个数字必须再用下游容量校验:DB 只能承受 40 并发,你开 285 个线程只会让 245 个线程排队。
3.3 真正的上限:下游容量
text
应用并发上限 = min(
线程/虚拟线程承载能力,
DB 连接池 × 安全系数,
Redis/RPC 并发上限,
CPU 可承受的序列化/计算
)
先算下游,再算线程。 这是 I/O 密集型系统最重要的顺序。
4. Spring Boot 开启虚拟线程
4.1 最小配置
yaml
spring:
threads:
virtual:
enabled: true
Spring Boot 3.2+ 会把 Tomcat 的请求处理切换到虚拟线程执行器。此时 server.tomcat.threads.max 不再是你以为的那个"并发上限",真正的限制来自连接池、信号量和下游。
4.2 不要池化虚拟线程
java
// 正确:每个任务一个虚拟线程
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
// 错误:把虚拟线程放进固定大小池
// Executors.newFixedThreadPool(200, Thread.ofVirtual().factory());
虚拟线程的设计目标就是"用完即弃",池化会失去意义,还可能引入线程局部变量污染。
4.3 用 Semaphore 保护下游
java
@Component
public class DbGate {
private final Semaphore permits = new Semaphore(32);
public <T> T call(Supplier<T> action) {
boolean acquired = false;
try {
acquired = permits.tryAcquire(50, TimeUnit.MILLISECONDS);
if (!acquired) {
throw new RejectedExecutionException("db gate rejected");
}
return action.get();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RejectedExecutionException("interrupted", e);
} finally {
if (acquired) permits.release();
}
}
}
为什么是 32?来自 DB 压测:在 64 并发时 P99 开始明显上升,应用侧取 40~50 总闸门,再按实例分摊。不是拍脑袋。
4.4 @Async 使用虚拟线程
java
@Configuration
@EnableAsync
public class AsyncConfig {
@Bean("bizExecutor")
public AsyncTaskExecutor bizExecutor() {
return new TaskExecutorAdapter(
Executors.newVirtualThreadPerTaskExecutor()
);
}
}
java
@Async("bizExecutor")
public CompletableFuture<Void> sendAudit(Order order) {
// 方法体已经由 @Async 调度到 bizExecutor,不要再嵌套 commonPool
auditClient.send(order);
return CompletableFuture.completedFuture(null);
}
注意:
@Async方法必须是 Spring Bean 的外部调用,自调用不会走代理。
5. Pinning:虚拟线程最大的坑
5.1 什么是 pinning
当虚拟线程在阻塞时无法卸载载体线程,就叫 pinned。常见原因:
synchronized块/方法内发生阻塞(JDK 21);- 调用 native 方法/JNI;
- 类初始化过程中的阻塞;
- 某些 JDBC 驱动、加密库的内部锁。
被 pin 住的虚拟线程会占着载体线程等待,并发能力退化为平台线程。大量 pinning 时,你会看到:
- 虚拟线程很多,但吞吐上不去;
- 载体线程池(ForkJoinPool)被打满;
- CPU 不高,但请求排队。
5.2 检测
bash
# JDK 21:打印 pinning 堆栈(仅诊断,生产慎用)
-Djdk.tracePinnedThreads=full
# JFR 事件
jdk.VirtualThreadPinned
bash
jcmd <pid> JFR.start name=vt settings=profile duration=60s filename=vt.jfr
5.3 修复
java
// 可能 pin:synchronized 内做 I/O
public synchronized User load(Long id) {
return jdbcTemplate.queryForObject(...); // 阻塞
}
// 改为 ReentrantLock
private final ReentrantLock lock = new ReentrantLock();
public User load(Long id) {
lock.lock();
try {
return jdbcTemplate.queryForObject(...);
} finally {
lock.unlock();
}
}
JDK 24 的 JEP 491 已改进
synchronized的 pinning 问题,但 JDK 21 仍需注意。升级前用 JFR 验证,不要假设"新版本一定没坑"。
6. ThreadLocal、MDC 与上下文传递
虚拟线程仍然支持 ThreadLocal,但:
- 每个虚拟线程一份副本,数量大时内存占用要评估;
InheritableThreadLocal在虚拟线程中默认继承行为要确认;- 线程池复用场景下,ThreadLocal 可能串数据;
- MDC、SecurityContext、TraceContext 不会自动跨线程传播。
6.1 TaskDecorator 传递 MDC
java
public class MdcTaskDecorator implements TaskDecorator {
@Override
public Runnable decorate(Runnable runnable) {
Map<String, String> context = MDC.getCopyOfContextMap();
return () -> {
if (context != null) MDC.setContextMap(context);
try {
runnable.run();
} finally {
MDC.clear();
}
};
}
}
java
@Bean("bizExecutor")
public ThreadPoolTaskExecutor bizExecutor() {
ThreadPoolTaskExecutor e = new ThreadPoolTaskExecutor();
e.setCorePoolSize(32);
e.setMaxPoolSize(32);
e.setQueueCapacity(200);
e.setTaskDecorator(new MdcTaskDecorator());
e.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
e.initialize();
return e;
}
6.2 更推荐:显式传参
在高并发链路里,尽量把 traceId、tenantId、deadline 作为方法参数或上下文对象显式传递,少依赖隐式 ThreadLocal。这样在异步、虚拟线程、反应式编程中都更稳。
7. 结构化并发:比裸 CompletableFuture 更好管
JDK 21 提供预览 API StructuredTaskScope,核心价值是:父子任务生命周期绑定,任一失败/超时可统一取消。
java
// JDK 21 预览 API,需 --enable-preview,后续版本 API 有演进
public OrderDetail detail(Long id) throws Exception {
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
var user = scope.fork(() -> userClient.get(id));
var order = scope.fork(() -> orderClient.get(id));
scope.join(); // 等待全部完成
scope.throwIfFailed(); // 任一失败则抛出
return new OrderDetail(user.get(), order.get());
}
}
对比 CompletableFuture.allOf:
| 能力 | CompletableFuture | StructuredTaskScope |
|---|---|---|
| 父子生命周期 | 手动 | 自动 |
| 失败取消其他任务 | 需手动 | 支持 |
| 超时 | 需组合 | joinUntil |
| 可读性 | 组合子复杂 | 接近同步代码 |
| 版本 | 稳定 | JDK 21 预览 |
生产使用前确认 JDK 版本和 API 稳定性;JDK 21 上建议先小流量验证。
8. CPU 密集型任务不要用虚拟线程
虚拟线程的优势是"阻塞时卸载"。CPU 密集型任务不会阻塞,虚拟线程只会增加调度开销,甚至降低吞吐。
正确分工:
text
I/O 密集型(DB/Redis/RPC/文件) -> 虚拟线程 + Semaphore
CPU 密集型(计算/加密/压缩/大 JSON) -> 固定大小平台线程池,大小 ≈ CPU 核数
混合型 -> 拆分任务,不要把 CPU 计算塞进虚拟线程
java
// CPU 密集型:固定平台线程池
ExecutorService cpuPool = Executors.newFixedThreadPool(
Runtime.getRuntime().availableProcessors()
);
9. 优雅停机
虚拟线程是守护线程,JVM 退出时不会等待它们完成。生产环境必须做优雅停机:
yaml
server:
shutdown: graceful
spring:
lifecycle:
timeout-per-shutdown-phase: 30s
java
@PreDestroy
public void shutdown() throws InterruptedException {
executor.shutdown();
if (!executor.awaitTermination(20, TimeUnit.SECONDS)) {
executor.shutdownNow();
}
}
同时确保:
- 网关先摘流,再停应用;
- 消费者先停止拉取,再处理完在途消息;
- 异步任务有最大执行时间,避免停机卡住。
10. 监控指标
| 指标 | 来源 | 关注点 |
|---|---|---|
| 活跃虚拟线程数 | JFR / Micrometer 自定义 | 突增说明下游变慢 |
| 载体线程池活跃数 | ForkJoinPool / JFR |
接近 parallelism 说明 pinning |
jdk.VirtualThreadPinned |
JFR | 持续出现要排查 |
| DB 信号量等待时间 | 自定义 Timer | P99 上升说明下游容量不足 |
| Hikari pending | Micrometer | >0 持续 1 分钟告警 |
| 请求 P99 | APM | 与线程/连接指标联动 |
| 拒绝数 | 自定义 Counter | 过载保护是否生效 |
11. 常见误区
| 误区 | 后果 | 正确做法 |
|---|---|---|
| 池化虚拟线程 | 失去轻量优势 | 每任务一个,Semaphore 限流 |
| 虚拟线程无限打 DB | DB 连接池/CPU 被打挂 | 下游并发闸门 |
在虚拟线程里大量 synchronized |
pinning,吞吐退化 | ReentrantLock,JFR 验证 |
| 用虚拟线程跑 CPU 任务 | 调度开销增加 | 固定平台线程池 |
| 以为开启虚拟线程就自动异步 | 阻塞调用仍然阻塞 | 理解挂载/卸载,配合非阻塞客户端 |
| 忽略 ThreadLocal 内存 | 大量虚拟线程内存膨胀 | 减少 ThreadLocal,显式上下文 |
| 不做优雅停机 | 请求丢失、任务中断 | graceful shutdown + 摘流 |
12. Checklist
text
[ ] 用 Little's Law 算过目标并发,不靠拍脑袋
[ ] 线程/虚拟线程上限由下游容量校验
[ ] 虚拟线程未池化
[ ] DB/Redis/RPC 有独立 Semaphore 或 Bulkhead
[ ] JDK 21 下检查 synchronized pinning
[ ] JFR 采集过 jdk.VirtualThreadPinned
[ ] CPU 密集型任务使用独立平台线程池
[ ] MDC/Trace/SecurityContext 显式传递
[ ] 线程池有界、拒绝策略明确、指标可观测
[ ] 优雅停机 + 网关摘流 + 消费者停止拉取
上一篇 :02 · 流量治理
下一篇 :04 · 缓存:从三兄弟到生产架构