Java 虚拟线程别乱用:I/O 密集型服务的线程模型与并发度计算

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,只有三条路:

  1. 降低 RT:缓存、索引、减少远程调用;
  2. 提高并发度:更多线程、异步、虚拟线程、扩容;
  3. 限流:承认容量不够,保护系统。

很多团队直接选 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:需要的并发请求数
  • λ:目标 QPS
  • W:平均 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 · 缓存:从三兄弟到生产架构

相关推荐
飞奔的瓜牛1 小时前
Zabbix 部署与实战监控手册:Java 服务、端口、进程与邮件/企微告警
java·企业微信·zabbix
Java展博2 小时前
[Go 后端转场] 从 try-catch 到 if err != nil:写惯 Java 的人第一次上手最别扭的 4 件事
java·开发语言·golang
starzy19902 小时前
Hadoop介绍总结:一张图理清组件、生态与版本
java·hadoop
yyuuuzz2 小时前
nginx 502 排查,先看上游超时那一行
android·java·运维·nginx·502
Java后端的Ai之路2 小时前
Java并发编程25-集合的线程安全
java·安全·面试
雪芽蓝域zzs2 小时前
第 3 章:完成 User 完整 CRUD(新增、根据 id 查询、修改、删除、查询全部)
spring boot
CoderYanger3 小时前
Java EE 进阶:9.MyBatis 操作数据库(进阶)(第一弹)
java·数据库·spring·面试·java-ee·tomcat·mybatis
码云社区3 小时前
Java租房平台源码方案:Vue 3房源审核、UniApp预约看房与房东管理
java·vue.js
codigger5 小时前
ThreadLocal 会内存泄露吗?
java·内存泄漏·threadlocal