Virtual Threads 还是 Reactor:大模型网关数据平面的实测选型

Virtual Threads 还是 Reactor:大模型网关数据平面的实测选型

Elvis Lv2

Java 21 之后,服务端并发模型似乎有了一个更简单的答案:使用虚拟线程,以同步方式编写代码,把异步调度和线程池管理交给 JVM。与此同时,Reactor 仍然是 Spring WebFlux、Reactor Netty 等高并发网络系统的核心。

两者真正的差别并不是”新技术替代旧技术”,也不是”谁的 benchmark 数字更高”,而是它们把并发、取消和流量控制放在了不同的位置。

我在 Libra(一个 Apache-2.0 的大模型网关与控制面)的数据平面选型上遇到了这个问题,于是实现了两套可运行的网关,在非流式请求、SSE、混合流量、客户端取消和慢客户端场景下做了对比。

先给结论,包括它的边界:

  • 1000 并发下,两套实现的吞吐和 p99 基本重合,错误率均为 0%。 但这个”平手”很大程度上是压测模型决定的,不能读作”性能相当”,后文会解释原因。
  • 1000 路 SSE 的隔离复测中,Reactor 实现的 Heap 峰值稳定在 156–164 MiB,Virtual Threads 实现为 566–618 MiB,约 3.5–4.0 倍;GC 停顿相差一个数量级。 这是方向稳定、可复现的差异。
  • 取消传播、慢客户端、Java 25 pinning 三个定向探针,两种实现全部通过。几个流传较广的”VT 不适合流式”论据,在这次测试里没有成立。

因此 Libra 最终没有做全局二选一,而是分区:数据平面的 HTTP/SSE 热路径使用 Reactor Core + Reactor Netty,控制面、计量任务和 JDBC 事务使用 Virtual Threads。

下面是这个选择的推导过程。

两种模型解决的是不同问题

Virtual Threads 首先解决的是线程成本问题。它允许应用为每个请求创建一个虚拟线程,以普通的顺序代码执行阻塞调用。虚拟线程在等待支持的阻塞 I/O 时会卸载 carrier thread,因此”一个请求一个线程”不再等价于”一个请求占用一个昂贵的操作系统线程”。

Reactor 解决的是异步数据流的组合问题。请求被表达为 Mono 或 Flux,数据只有在下游发出 demand 时才向前推进,取消也沿订阅关系传播。少量 Event Loop 可以管理大量连接,但前提是应用不能在 Event Loop 上执行阻塞操作。

维度 Virtual Threads Reactor
主要抽象 每请求一个虚拟线程 Mono / Flux 数据流
代码形态 顺序式、命令式 声明式、组合式
等待 I/O 挂起虚拟线程 注册回调,由 Event Loop 推进
取消 中断、关闭流、取消 Future,并由业务层协作 Subscription cancellation 沿管线传播
背压 需要显式设计有界队列、写超时和上游暂停 Reactive Streams 提供 demand 协议,缓冲仍需显式设限
阻塞代码 通常可以直接调用 必须移出 Event Loop
典型优势 易读、易调试,适配 JDBC 和阻塞 SDK 流式组合、取消传播和高连接密度
主要代价 每请求状态和具体 I/O 栈仍有资源成本 调用链和上下文调试更复杂

这里有两个常见误区。

第一,Virtual Threads 让阻塞变得便宜,但不会自动提供背压。生产者快于消费者时,系统仍然需要决定暂停上游、限制缓冲,还是丢弃数据。

第二,Reactor 提供了背压协议,但不代表使用 Reactor 就天然安全。无界的 onBackpressureBuffer、过大的预取或在 Event Loop 上调用阻塞 SDK,一样会让系统失控。

为什么大模型网关格外关注流式语义

普通 Web API 往往是读取请求、查询数据库、生成响应。大模型网关的数据平面还要处理持续数秒甚至数分钟的 SSE:

1
2
3
4
5
6
7
client
-> admission / concurrency lease
-> provider request
-> SSE decode and protocol conversion
-> tool-call incremental assembly
-> downstream SSE write
-> finalizer / metering

这条链路中,客户端可能随时断开,Provider 可能长时间没有返回 token,下游也可能读取很慢。一次取消需要同时停止上游读取、释放并发 Lease、结束计量并避免重复 Finalize。一次背压失效则可能让每条长连接都积累缓冲,最终把单连接问题放大成实例级内存问题。

Virtual Threads 能实现这些语义:客户端断开后关闭响应流、取消上游请求,并在 finally 中做幂等清理。问题不在于”能不能”,而在于取消、中断、Future 和资源关闭需要在每一层保持一致。

Reactor 可以把下游取消作为整条 Subscription 的信号,并用 doFinally 或资源管理算子连接清理逻辑。这与 Libra 已有的 Reactor Netty 管线更匹配,也更方便审计。但 Finalizer 仍然必须幂等,网络写入仍然必须有界,框架不会替业务代码完成这些约束。

同一条 SSE 请求的两种控制流

省略协议转换和错误处理后,Virtual Threads 版本接近普通的流复制:

1
2
3
4
5
6
7
8
9
10
11
12
try (var reader = new BufferedReader(new InputStreamReader(upstream.body()));
var output = downstream.getResponseBody()) {
String line;
while ((line = reader.readLine()) != null) {
output.write((line + "\n").getBytes(UTF_8));
if (line.isEmpty()) {
output.flush();
}
}
} finally {
finalizeOnce();
}

它的优点是执行顺序和资源生命周期很直观。要让这段代码成为完整的网关实现,还需要定义下游写失败如何取消上游、阻塞写多久算超时,以及 Finalizer 如何区分完成、取消和错误。

Reactor 版本把响应体保持为一条流:

1
2
3
return upstream.response((response, content) ->
downstream.send(content.retain()).then())
.doFinally(signal -> finalizeOnce());

下游取消会终止订阅,并沿管线取消 upstream publisher。代价是资源引用计数、异步错误边界和 Context 传播都需要团队熟悉,排查问题时也不能只阅读当前线程的调用栈。

这正是两者最实际的取舍:Virtual Threads 把复杂度留在资源关闭和协作式取消边界,Reactor 把复杂度放在异步管线及其调试模型中。

测试是怎么搭的

测试运行于 Apple M4 Mac mini(4P + 6E 共 10 核)、16 GB 内存、macOS 15.2 和 Oracle GraalVM for JDK 25,时间为 2026-08-12。测试件是一个独立 Gradle 项目,包含同一个 mock Provider、两个 gateway 和同一个 Reactor Netty 负载器:

  • Reactor gateway:Reactor Netty server/client,SSE 以 ByteBuf Flux 透传。
  • VT gateway:JDK HttpServer + newVirtualThreadPerTaskExecutor() + JDK HttpClient,SSE 逐行读取并 flush。
  • direct 基线:负载器直连 mock Provider,用来标定”零网关”时的数值。
  • mock Provider:非流式请求随机延迟 50–200 ms;流式请求返回 5–10 个 79-byte SSE record,总时长 200–600 ms。
  • 正式矩阵:100、500、1000 并发 × 非流式 / SSE / 70-30 混合,预热 5 s、测量 15 s。
  • 定向探针:取消传播、慢客户端、Java 25 pinning。

所有流量都在同一台机器上通过 HTTP/1.1 loopback 运行。负载是 closed-loop,每个连接同一时刻只有一个在途请求。因此这是一组用于架构决策和回归的系统测试,不是隔离 scheduler 的微基准,也不是生产容量测试。

1000 并发:吞吐”打平”,但这不是发现

正式矩阵的 1000 并发结果如下,两种实现的已完成请求错误率均为 0%:

场景 实现 RPS p99 Heap 峰值 GC 时间 平均 CPU
非流式 direct 7912.0 199.2 ms 149.6 MiB 23 ms 0.42 核
非流式 Reactor 7871.3 199.7 ms 159.5 MiB 36 ms 0.62 核
非流式 VT 7866.0 200.2 ms 404.2 MiB 136 ms 1.14 核
SSE direct 2448.5 594.4 ms 151.3 MiB 6 ms 0.35 核
SSE Reactor 2412.5 604.5 ms 176.6 MiB 26 ms 0.74 核
SSE VT 2448.3 594.5 ms 760.9 MiB 144 ms 0.98 核
70/30 混合 direct 4764.1 584.4 ms 149.8 MiB 10 ms 0.30 核
70/30 混合 Reactor 4756.2 585.0 ms 189.0 MiB 22 ms 0.51 核
70/30 混合 VT 4757.4 585.4 ms 678.7 MiB 47 ms 0.96 核

很多同类评测会在这里宣布”两种模型性能相当”。但把 direct 基线放进来之后,更诚实的读法是另一回事:这个矩阵根本没有把任何一方压到饱和。

三个证据:

  1. closed-loop 负载下 RPS ≈ 并发数 / 平均延迟。非流式 p50 是 125 ms,1000 / 0.125 = 8000,实测 7866–7912;SSE p50 是 396 ms,1000 / 0.4 = 2500,实测 2412–2448。吞吐完全由 mock Provider 的人造延迟决定。
  2. 三种实现的 RPS 在 100 / 500 / 1000 并发上严格线性,没有任何拐点。
  3. 10 核机器上,网关进程平均只用掉 0.5–1.1 核。

所以正确的结论不是”吞吐打平”,而是:**在这个负载水平下,两个网关都没有引入可测量的额外延迟,也都没有产生错误。**这是一次通过/不通过的一致性验证,不是容量对比。宣称”Reactor 一定更快”或”Virtual Threads 已经让响应式模型失去性能价值”,这份数据都不支持。

真正在这张表里分化的是右边三列:Heap、GC 和 CPU。而 Heap 是同一 JVM 顺序跑完整矩阵的高水位,会被此前场景污染,所以需要单独复测。

1000 路 SSE 隔离复测:资源密度出现稳定差异

为降低干扰,每个 gateway 使用全新 JVM,只运行 1000 并发 SSE,预热 10 秒、测量 30 秒,并在第二轮反转执行顺序:

执行顺序 实现 RPS p99 Heap 峰值 GC 时间 平台 / 虚拟线程峰值
Reactor → VT Reactor 2483.1 594.5 ms 156.1 MiB 29 ms 18 / 0
Reactor → VT VT 2277.4 796.3 ms 618.0 MiB 425 ms 275 / 1002
VT → Reactor VT 2385.8 656.8 ms 566.0 MiB 575 ms 260 / 1004
VT → Reactor Reactor 2191.0 796.4 ms 164.2 MiB 78 ms 18 / 0

反转顺序后,后运行的一方都出现了吞吐下降和 p99 上升——包括 Reactor 自己。这说明 CPU 热状态、GC、端口复用足以改变性能排名,所以吞吐和尾延迟的胜负不能作为结论。

但资源差异在两轮中方向一致:

  • Reactor Heap 峰值 156.1–164.2 MiB,VT 为 566.0–618.0 MiB,约 3.5–4.0 倍。
  • Reactor GC 时间 29–78 ms,VT 为 425–575 ms。
  • Reactor 平台线程恒定 18 个;VT 实现需要 260–275 个平台线程加约 1000 个虚拟线程。

需要说清归因:这比较的是两套完整实现,不只是 Reactor 与虚拟线程调度器。VT 侧的平台线程数量很大程度上来自 JDK HttpClient 的实现方式,不能记在虚拟线程本身账上——换一个非阻塞 HTTP 客户端,这个数字会变。

尽管如此,从部署视角看要承担成本的是完整系统的实例资源,而不是某个组件的理论开销。两轮方向一致的 Heap 与 GC 差异,是选择 Reactor 数据平面的最强量化依据。

三个定向探针:常见的反 VT 论据没有成立

取消传播。 探针先确认 50 个请求全部到达 upstream,再断开 downstream,随后轮询观察取消是否传播到 Provider:

实现 传播成功 P50 P99 P999
Reactor 50 / 50 29 ms 33 ms 33 ms
VT 50 / 50 39 ms 40 ms 40 ms

两者都满足 P99 <= 100 ms。这直接否定了”VT 的取消只能依赖不可验证的 Thread.interrupt()“这种过度概括。正确的工程要求是:无论使用哪种模型,都必须用端到端测试确认客户端断开确实到达 upstream,并最终释放业务资源。

慢客户端。 20 个客户端各读取一个 5000-record 的 SSE 响应,每读 256 byte 后等待 10 ms。两种实现都完整结束 20/20,没有客户端失败。但这只能说明两个具体实现能完成该场景:测试没有设置很小的每流内存上限,也没有直接观测 TCP window、upstream demand 和 Netty 发送队列,因此不能据此宣布已满足生产级背压要求。

Java 25 pinning。 早期 Virtual Threads 讨论常把 synchronized 导致 carrier thread pinning 作为主要风险,但 JEP 491 已经改变了这一点。我们把虚拟线程 scheduler parallelism 固定为 10,启动 1000 个虚拟线程,让每个线程在独立的 synchronized monitor 中 sleep 100 ms:总耗时约 114 ms,jdk.tracePinnedThreads=full 没有产生输出。如果这些 monitor 仍然固定 carrier,理论耗时会接近 10 秒。

所以在 Java 25 上继续声称”synchronized 必然 pin carrier”是不准确的。但这次探针不覆盖 native/FFM 调用或第三方库的具体路径——pinning 仍应通过 JFR 持续审计,只是不能再作为 Reactor 天生更快的论据。

应该如何选择

更适合优先考虑 Virtual Threads:

  • 请求主要是 unary 调用,生命周期短,流式传输不是核心路径。
  • 依赖 JDBC 或以阻塞 API 为主的 SDK。
  • 团队希望保留顺序式控制流和普通栈跟踪。
  • 取消与背压可以通过少量、清晰的边界实现。

更适合继续使用 Reactor:

  • 系统已经建立在 Netty/WebFlux 的非阻塞管线上。
  • SSE、WebSocket 或长时间流式请求占据主要流量。
  • 下游取消和 demand 需要贯穿多个转换阶段。
  • 单实例需要维持大量连接,并对每流缓冲和实例内存有严格预算。

这不是只能选一个的架构。对 Libra 而言,数据平面保持 Reactor 可以延续现有的 transport cancellation 和 Reactive Streams demand;控制面、JDBC 事务和计量批处理使用 Virtual Threads,则可以保留同步代码的可读性。阻塞 SDK 如果必须进入数据平面,会被放到显式隔离的 worker 或虚拟线程边界,而不是占用 Netty Event Loop。

结论,以及结论的边界

本次实测没有证明 Reactor 在吞吐和延迟上普遍优于 Virtual Threads。它证明的是一件更具体、也更有决策价值的事:

在 Libra 当前的 Reactor Netty 与 JDK HTTP 实现下、1000 路 SSE 场景中,Reactor 在保持相同吞吐、尾延迟和零错误率的同时,表现出约 4 倍的 Heap 资源密度优势和一个数量级的 GC 优势,且该差异在反转执行顺序后依然成立。

这个结论有清晰的边界,值得逐条写下来:

  • 单机 loopback + closed-loop 负载会产生 coordinated omission,自制 histogram 不能替代 HdrHistogram。
  • 测量窗口结束时仍在途的请求属于 censored samples,不能被简单算作成功或失败。
  • mock Provider 没有包含真实的 Redis 接纳、完整 SSE 解码重编码、工具调用拼装、Finalizer 和计量发布。
  • BufferPoolMXBean 在本机 Netty 4.2 allocator 下只报告 8 B,因此 Direct Memory 结论无效——而这恰恰是 Netty 侧最该看的指标。
  • VT 侧的线程数量受 JDK HttpClient 影响,换客户端结论可能变化。

要把结论推向容量规划,还需要独立负载机、open-loop 流量、随机顺序的多轮重复与置信区间、1k/5k/10k 长连接、受限 Heap 的慢客户端测试,以及 JFR 和 Netty allocator 指标。

在这些证据出现之前,我把 Reactor 作为 Libra 数据平面的当前最优解,而不是 Java 并发模型的最终答案。

数据与复现

1
2
3
4
git clone https://github.com/qianwj/libra.git
cd libra/bench/concurrency-model
./gradlew test
./run-benchmark.sh

脚本支持 BENCH_JAVA_HOME、WARMUP_SECONDS、MEASURE_SECONDS、CONCURRENCY_LEVELS、SCENARIOS、GATEWAYS 等环境变量。完整默认矩阵较重,建议先用 README 里的 smoke 命令验证环境。

  • 标题: Virtual Threads 还是 Reactor:大模型网关数据平面的实测选型
  • 作者: Elvis
  • 创建于 : 2026-08-16 11:00:00
  • 更新于 : 2026-08-16 09:13:38
  • 链接: https://qianwj.github.io/2026/08/16/virtual-threads-vs-reactor/
  • 版权声明: 本文章采用 CC BY-NC-SA 4.0 进行许可。