Skip to content

2.4-14 响应式编程:Reactor 背压与适用场景 ​

所属:02 Java 运行时 / 2.4 并发 分级:B(按 A 类模板展开) 状态:◐ 初稿 关联:2.4-6、2.4-11、2.4-12、2.4-13、3.2-1、6.7-4

  • 题型:原理 / 对比 / 场景

  • 一句话结论:响应式编程的核心不是“异步”,而是 Reactive Streams 的拉取式背压:下游用 request(n) 告诉上游“我还能消费多少”,上游按需生产,整条链路不能有人偷偷攒数据;Reactor 用 Flux(0..N)和 Mono(0..1)实现这套协议,靠 publishOn/subscribeOn 切线程、靠 flatMap/concatMap/limitRate 控制并发。它适合流式、网关、高并发 IO 和需要端到端背压的场景,不适合简单 CRUD、阻塞 JDBC、事务密集和团队不熟的业务系统——在事件循环里 block() 或调 JDBC,会把优势直接变成事故。

  • 分层要点:

    1. 先纠正一个误解:响应式不是“用线程池做异步”,而是基于需求的流控。Reactive Streams 规定 Publisher/Subscriber/Subscription 三个角色,订阅后下游通过 Subscription.request(n) 声明需求,上游最多发 n 个 onNext,最后以 onComplete/onError 终止。没有 request 就没有数据,这是它和 CompletableFuture、线程池队列最本质的区别(2.4-13)。
    2. Flux 与 Mono:Flux<T> 表示 0..N 个元素,Mono<T> 表示 0..1 个元素,两者都是 Publisher,都惰性——不订阅就不执行。创建方式有 just/fromIterable/fromCallable/defer/create/generate/interval/from(Publisher);defer 每次订阅才创建源,fromCallable 会捕获异常转成 onError,just 在装配时就求值。冷流每次订阅都会重新执行源,这一点决定了重复调用与 cache/share 的必要性。
    3. 背压的端到端语义:背压只有在每一段都遵守协议时才成立。limitRate(n) 把下游请求拆成批次;flatMap(mapper, concurrency, prefetch) 用并发度和预取量控制上游请求;concatMap 串行保证顺序;onBackpressureBuffer/Drop/Latest/Error 是上游不守规矩时的兜底策略。到了 JDBC、阻塞 HTTP 客户端、消息队列这类外部系统,背压传不过去,只能靠有界并发、超时、队列上限和限流兜底。
    4. 线程模型:publishOn 与 subscribeOn:subscribeOn 影响订阅过程(也就是上游源在哪个调度器上被订阅、请求信号从哪发出),放哪儿都作用于上游,多次使用时最靠近源的那个生效;publishOn 影响它下游的 onNext/onComplete/onError 在哪个调度器执行,可以多次出现、逐段切换。记住口诀:subscribeOn 管上游订阅,publishOn 管下游执行。
    5. 调度器选型:Schedulers.parallel() 是固定大小的 CPU 型线程池(默认核数个线程),适合计算,不能阻塞;boundedElastic() 是为阻塞调用准备的有界弹性池(默认 10×核数线程、每线程约 10 万任务队列、空闲回收),适合 JDBC/阻塞 SDK;single() 单线程;immediate() 当前线程;fromExecutor() 接自定义池。WebFlux 默认跑在 Reactor Netty 的 event loop 上,线程很少,任何阻塞都会拖垮整个事件循环。
    6. 操作符与语义:map 同步转换、flatMap 异步展开且可能交错、concatMap 保序串行、flatMapSequential 保序但并发、zip/merge/concat/combineLatest 组合、filter/distinct/take/skip 过滤、buffer/window/sample/throttle 聚合与限速。错误是终止信号:onError 之后的正常操作符不再执行;用 onErrorReturn/onErrorResume/onErrorMap 恢复,用 retry/retryWhen(Retry) 重订阅,用 timeout 取消上游(协作式,阻塞调用未必响应)。
    7. 冷热流与 Context:冷流每个订阅独立执行;热流(Sinks、ConnectableFlux、publish/share/replay)共享同一份数据,晚订阅者可能错过元素,replay 会缓存。Context 是 Reactor 自己的不可变上下文,contextWrite 写在链尾、可被上游 deferContextual 读取;它不传播到 ThreadLocal/MDC,跨线程日志需要 Hooks.onEachOperator/Schedulers.onScheduleHook 或显式桥接。
    8. 适用与边界:适合流式数据处理、SSE/WebSocket、API 网关、高并发 IO 聚合、需要背压的管道;不适合简单 CRUD、JPA/JDBC 阻塞链路、复杂事务、CPU 密集计算和调试能力不足的团队。响应式的收益来自“少量线程 + 非阻塞 + 背压”,代价是学习曲线、堆栈难读、调试和排障成本高;如果只是把阻塞代码搬进 Mono,不如用 Spring MVC + 虚拟线程(2.4-11)。选型要看下游是否真的支持非阻塞,而不是看“响应式”这个词。
  • 图/流程:

text
Reactive Streams 的拉取式背压:

  Subscriber                Subscription               Publisher
     │  subscribe()  ───────────►  onSubscribe(sub)  ──────►
     │  sub.request(n) ───────────────────────────────────►
     │  ◄──────────────────────────  onNext(x) ≤ n 个
     │  ◄──────────────────────────  onComplete() / onError(e)
     │
  没有 request 就没有数据;request 是累计需求,上游必须遵守
text
publishOn vs subscribeOn:

  source ── op ── op ── publishOn(A) ── op ── subscribeOn(B) ── subscribe

  subscribeOn(B):订阅/请求信号在 B 上发生(影响上游)
  publishOn(A):A 之后的下游 onNext/onComplete 在 A 上执行
  多个 subscribeOn:最靠近源的那个决定源在哪个线程订阅
text
flatMap 的并发与背压:

  Flux<Id> ──flatMap(call, concurrency=32, prefetch=64)──►
      同时最多 32 个内层 Publisher 在跑
      向上游预取 64 个元素
      结果可能交错(不保序)→ 需要保序用 concatMap / flatMapSequential

  limitRate(64):把下游请求拆成 64 一批,避免一次性拉爆上游
text
错误是终止信号:

  onNext → onNext → onError ──► 流结束,后续正常操作符不执行
                                    │
                    onErrorResume ──► 切换到备用流
                    retry(n) ──────► 重新订阅(冷流会重跑源)
                    timeout ───────► 取消上游并发出 TimeoutException
java
// 非阻塞聚合(示意)
Flux.fromIterable(ids)
    .flatMap(id -> asyncRpc.call(id), 32)          // 并发上限 32
    .limitRate(64)                                  // 分批请求
    .timeout(Duration.ofMillis(500))
    .onErrorResume(e -> Mono.empty())               // 降级
    .publishOn(Schedulers.parallel());              // 下游在 parallel 执行

// 阻塞调用必须切到 boundedElastic
Mono.fromCallable(() -> blockingJdbc.query(id))
    .subscribeOn(Schedulers.boundedElastic());
text
冷流重复订阅:

  Mono<Resp> m = Mono.fromCallable(() -> rpc.call(id));  // 冷流
  m.subscribe(...);   // 调一次
  m.subscribe(...);   // 再调一次!源被执行两遍
  需要共享:cache() / share() / Sinks
  • 版本/源码锚点:

    • Reactive Streams 1.0.x 规范:org.reactivestreams.Publisher/Subscriber/Subscription/Processor;JDK 9 的 java.util.concurrent.Flow 是同类模型的另一套接口,Reactor 不与它混用。
    • Reactor 3.x:reactor.core.publisher.Flux/Mono、Schedulers、Sinks(3.4+)、Retry/RetrySpec、Context、StepVerifier;Reactor 3.6+ 基线 Java 17,具体版本按项目确认。
    • flatMap 默认并发 256、预取 256;limitRate/onBackpressureBuffer 默认缓冲约 256(Queues.SMALL_BUFFER_SIZE);boundedElastic 默认 10×CPU 线程、每线程约 10 万队列、空闲 60s 回收。
    • Spring:Spring Framework 5+ 的 WebFlux、WebClient、ReactiveTransactionManager、R2DBC;Spring Boot 3.x 的响应式栈;3.2-1 里 Web 类型推断与 WebFlux 选型。
    • 观测:Reactor 的 checkpoint()、Hooks.onOperatorDebug()(开发期,开销大)、Micrometer/Actuator 指标;StepVerifier/TestPublisher 做背压单测。
  • Flux 与 Mono 对比:

维度Flux<T>Mono<T>
元素个数0..N0..1
典型场景列表、流、SSE、消息单次 RPC、单条查询、命令
空结果onComplete 无元素Mono.empty()
转换map/flatMap/filtermap/flatMap
聚合collectList/collectMap/reducethen/zipWith
订阅subscribe 后可接收多个最多一个
  • publishOn 与 subscribeOn 对比:
维度subscribeOnpublishOn
影响范围订阅过程与上游请求信号下游的 onNext/onComplete/onError
放置位置链上任意位置,作用于上游只影响其后的操作符
多次出现最靠近源的生效每处都切换下游线程
典型用途把阻塞源放到 boundedElastic把计算/序列化切到 parallel
常见误区以为能切换下游线程以为能改变上游订阅线程
  • 调度器选型表:
调度器线程模型适用禁止
parallel()固定 CPU 核数计算、转换阻塞 IO
boundedElastic()10×CPU、有界队列、空闲回收JDBC、阻塞 SDK当作无限池滥用
single()单线程低频串行任务高并发
immediate()当前线程测试/简单场景阻塞事件循环
fromExecutor()自定义池复用现有线程池无界队列
Reactor Netty event loop少量 IO 线程WebFlux 请求处理任何阻塞调用
  • 背压策略表:
策略行为适用风险
request(n) / limitRate(n)分批拉取正常流控需求过小会降低吞吐
onBackpressureBuffer缓冲超额元素上游不支持背压、短时突发缓冲无界会 OOM
onBackpressureDrop丢弃新元素允许丢的监控/采样数据缺失
onBackpressureLatest只保留最新状态类数据中间值丢失
onBackpressureError超限抛 OverflowException不能丢、不能缓冲上游需处理错误
flatMap(concurrency, prefetch)限制内层并发与预取并发调用下游并发过大打满下游
buffer/window聚合成批批量写/批处理批次过大占内存
  • Reactor vs 虚拟线程 vs CF vs 结构化并发:
维度Reactor/WebFlux虚拟线程 (JDK 21)CompletableFutureStructuredTaskScope
编程模型声明式流、操作符同步阻塞式回调/链式同步 + 子任务树
背压内建(Reactive Streams)需信号量/队列/连接池无无(靠 join/超时)
线程占用事件循环少量线程每任务一个虚拟线程线程池虚拟线程 + scope
调试堆栈难读,需 checkpoint栈完整回调链较散栈较完整
失败取消onError/cancel 传播同步异常/中断不向上游传播自动取消兄弟
适用流式、网关、强背压阻塞 IO、CRUD、迁移友好简单扇出请求级并发分解
  • 常见坑清单:
现象根因处理
WebFlux 吞吐骤降/请求超时在 event loop 里 block() 或 JDBC移除阻塞;必须阻塞则切 boundedElastic
下游被打满flatMap 默认并发 256显式设 concurrency/prefetch + 限流
OverflowException上游产生快于下游请求limitRate/buffer/drop 或调并发
流“没执行”只装配没订阅返回给框架或显式 subscribe
同一个 RPC 调了两次冷流被重复订阅cache/share 或复用同一个 Mono
日志没有 traceIdContext 不传播到 MDConScheduleHook/onEachOperator 桥接
错误后整条链静默onError 是终止信号且未处理onErrorResume/onErrorMap + 监控
retry 放大故障无退避、无限重试Retry.backoff + 上限 + 熔断
timeout 没生效下游阻塞不响应取消下游客户端超时 + 有界并发
内存持续上涨无界 buffer、replay 缓存过大有界队列、限制缓存、及时 dispose
顺序错乱flatMap 并发交错concatMap 或 flatMapSequential
订阅无人管理手动 subscribe() 后丢失交给框架,或用 Disposable 管理
  • 深挖点(面试官常追的 6 个):

    1. 背压到底是什么:它是需求驱动的流控协议:下游 request(n) 声明还能消费多少,上游最多发 n 个。它和“有界队列 + 拒绝策略”不同:队列是缓冲,背压是让生产端降速。端到端成立的前提是每一段都实现 Publisher 协议;一旦进入阻塞 JDBC/HTTP,背压就断了,只能用并发度、超时和队列上限做近似。
    2. publishOn 与 subscribeOn 的线程语义:subscribeOn 切换的是订阅动作发生的调度器,影响上游源在哪个线程被订阅和请求;publishOn 切换的是信号向下游传递的调度器。放在链中间时,publishOn 只影响它下游;subscribeOn 无论放哪儿都作用于上游,多次出现时最靠近源的生效。实际排障时先看“源在哪个线程跑”,再看“下游回调在哪个线程跑”。
    3. flatMap 的并发、顺序与背压:flatMap 会同时订阅最多 concurrency 个内层 Publisher,向上游预取 prefetch 个元素,结果按完成顺序交错;concatMap 串行、保序但吞吐低;flatMapSequential 并发执行但按源顺序发射。并发度太大打满下游,太小浪费吞吐;limitRate 控制请求批次,避免一次拉太多。
    4. 错误、重试、超时的语义:onError 是终止信号,流结束后不会再有元素;onErrorResume 切换到备用 Publisher,onErrorMap 转换异常类型,retry/retryWhen 重新订阅(冷流会重新执行源,注意幂等),timeout 在超时后取消上游并发出 TimeoutException。取消是协作式的:阻塞调用如果不在可中断点,未必立刻停下。
    5. 冷热流与 Context:冷流每次订阅独立执行,适合“一次请求一次调用”;重复订阅会重复执行,需要 cache/share。热流用 Sinks/ConnectableFlux 广播,晚订阅者可能错过数据,replay 会缓存。Context 是不可变映射,contextWrite 写在链尾、对上游可见;它不进入 ThreadLocal,日志 MDC 要额外桥接。
    6. 响应式适合与不适合的边界:适合流式数据、网关、SSE/WebSocket、非阻塞客户端、需要端到端背压的管道;不适合阻塞 JDBC/JPA、复杂事务、简单 CRUD、CPU 密集和团队调试能力不足的场景。Spring MVC + 虚拟线程在阻塞 IO 上往往更简单;WebFlux 的价值在“少量线程支撑高并发 + 流式 + 背压”,而不是“响应式一定更快”。
  • 追问链:

    1. 什么是响应式编程? → 基于数据流和变化传播的编程模型,Reactor 里体现为 Publisher/Subscriber 的异步流。
    2. 响应式的核心是异步吗? → 不是,核心是 Reactive Streams 的背压协议。
    3. Reactive Streams 有哪几个接口? → Publisher/Subscriber/Subscription/Processor。
    4. 背压怎么工作? → 下游 request(n) 声明需求,上游最多发 n 个 onNext。
    5. 为什么需要背压? → 生产快于消费时避免无界缓冲、OOM 和雪崩。
    6. Flux 和 Mono 区别? → Flux 0..N,Mono 0..1。
    7. 不订阅会执行吗? → 不会,Reactor 是惰性的。
    8. 冷流和热流区别? → 冷流每个订阅独立执行,热流共享数据。
    9. 重复订阅会怎样? → 冷流会重复执行源,可能重复调用下游。
  1. 怎么避免重复执行? → cache/share、复用同一个 Publisher、Sinks。
  2. just 和 defer 区别? → just 装配时求值,defer 每次订阅才创建源。
  3. fromCallable 有什么用? → 包装阻塞调用并捕获异常转成 onError。
  4. publishOn 干什么? → 切换它下游信号执行的调度器。
  5. subscribeOn 干什么? → 切换订阅/请求信号发生的调度器,影响上游。
  6. 两者能互换吗? → 不能,作用方向不同。
  7. 多个 subscribeOn 谁生效? → 最靠近源的那个。
  8. parallel 调度器适合什么? → CPU 计算,不能阻塞。
  9. boundedElastic 适合什么? → 阻塞 IO/JDBC,有界弹性池。
  10. WebFlux 默认在哪个线程? → Reactor Netty event loop。
  11. 在 event loop 里 block 会怎样? → 拖垮事件循环,吞吐骤降。
  12. flatMap 会保序吗? → 不保序,按完成顺序交错。
  13. 怎么保序? → concatMap 或 flatMapSequential。
  14. flatMap 默认并发多少? → 256(具体按版本)。
  15. 怎么限制并发? → 显式传 concurrency/prefetch,配合 limitRate。
  16. limitRate 干什么? → 把请求拆成批次,控制预取。
  17. 上游不守背压怎么办? → onBackpressureBuffer/Drop/Latest/Error。
  18. buffer 有什么风险? → 无界缓冲 OOM。
  19. onError 之后还能继续吗? → 不能,onError 是终止信号。
  20. 怎么恢复错误? → onErrorReturn/onErrorResume/onErrorMap。
  21. retry 会重新执行源吗? → 会重新订阅,冷流会重跑。
  22. retry 有什么风险? → 无退避会放大故障,需 Retry.backoff + 熔断。
  23. timeout 会取消上游吗? → 会发出取消,但阻塞调用未必响应。
  24. Context 是什么? → Reactor 的不可变上下文,随流传播。
  25. contextWrite 写在哪? → 链尾,对上游可见。
  26. Context 会进 ThreadLocal 吗? → 不会,MDC 需桥接。
  27. 怎么在日志里带 traceId? → onScheduleHook/onEachOperator 桥接 Context 与 MDC。
  28. Sinks 是什么? → 手动创建热流的 API,支持单播/多播/replay。
  29. replay 有什么风险? → 缓存无界会占内存。
  30. 响应式能做事务吗? → 可以配 R2DBC 的 ReactiveTransactionManager,但不能混阻塞 JDBC。
  31. 响应式和虚拟线程怎么选? → 流式/背压/网关用 Reactor;阻塞 IO/CRUD 用虚拟线程更简单。
  32. 响应式和 CompletableFuture 怎么选? → 简单扇出用 CF;流式组合、背压、取消传播用 Reactor。
  33. 响应式一定更快吗? → 不一定,只在高并发 IO + 非阻塞链路下体现优势。
  34. 怎么调试响应式? → checkpoint()、Hooks.onOperatorDebug()(开发期)、StepVerifier、日志操作符。
  35. 怎么测试背压? → StepVerifier 和 TestPublisher 精确控制请求量。
  36. 面试怎么总结? → Reactive Streams 协议 → request(n) 背压 → Flux/Mono → publishOn/subscribeOn → flatMap 并发 → 错误/重试/超时 → 冷热流/Context → 与虚拟线程/CF 的选型。
  • 生产案例/取舍(示例,替换成你的项目):

    • WebFlux 接口里调用了阻塞 JDBC,压测时 RT 飙升、event loop 被打满;改为 R2DBC,或把阻塞调用切到 boundedElastic 并限制并发。
    • flatMap 默认并发 256 调用下游,促销时把下游打挂;显式降到 32 并加 limitRate、超时和熔断。
    • 上游产生速度是下游的 10 倍,出现 OverflowException;加 onBackpressureBuffer(有界) + limitRate,超限降级。
    • 同一个 Mono 被订阅两次,RPC 调了两遍,产生重复订单;改用 cache() 或只订阅一次。
    • 响应式链路里抛异常后接口一直无响应;补 onErrorResume 和统一错误码。
    • retry 没有退避,下游故障时重试风暴;改 Retry.backoff + 次数上限 + 熔断。
    • timeout 设为 500ms,但阻塞客户端不响应取消,线程仍被占用;补客户端读超时和连接池上限。
    • 日志里 traceId 丢失;用 Hooks.onEachOperator 把 Reactor Context 桥接到 MDC。
    • 网关转发大响应时内存上涨;用 DataBuffer 流式转发,避免 collectList 全量缓冲。
    • SSE 推送用 Flux.interval 但客户端断开后仍跑;监听取消信号并释放资源。
    • 用 publishOn(parallel()) 跑 JDBC,parallel 池被阻塞;改 boundedElastic。
    • 简单 CRUD 强行改成 WebFlux,团队排障困难、收益为零;回退 Spring MVC + 虚拟线程。
    • 取舍:Reactor 换端到端背压和少量线程高并发,代价是学习曲线、堆栈可读性和调试成本;虚拟线程换同步写法的简单性,代价是仍需自己做背压/限流;WebFlux 换流式与低延迟,代价是生态(JDBC/事务)受限;CF 换轻量编排,代价是无背压。
  • 易错点:

    • 认为响应式就是异步线程池,实际核心是背压协议。
    • 认为 Flux 装配后就执行,实际不订阅不执行。
    • 认为冷流订阅多次只执行一次,实际每次订阅都重跑。
    • 认为 just 和 defer 等价,实际求值时机不同。
    • 认为 publishOn 能切换上游订阅线程,实际它只影响下游。
    • 认为 subscribeOn 能切换下游回调线程,实际它影响订阅/请求。
    • 认为多个 subscribeOn 会叠加,实际最靠近源的生效。
    • 认为 parallel() 可以跑阻塞 IO,实际会占满计算线程。
    • 认为 boundedElastic 是无限池,实际有线程和队列上限。
    • 认为 WebFlux 里可以随便 block(),实际会拖垮 event loop。
    • 认为 flatMap 保序,实际按完成顺序交错。
    • 认为 concatMap 和 flatMap 性能一样,实际前者串行。
    • 认为 flatMap 默认并发很小,实际默认 256。
    • 认为背压能穿透 JDBC/阻塞 HTTP,实际不能。
    • 认为 onError 之后还能继续处理,实际它是终止信号。
    • 认为 retry 不会重跑源,实际会重新订阅冷流。
    • 认为 timeout 一定能停止下游,实际取消是协作式的。
    • 认为 Context 会进 ThreadLocal,实际不会。
    • 认为 MDC 会自动带 traceId,实际需要桥接。
    • 认为 Sinks 的 replay 无成本,实际缓存会占内存。
    • 认为响应式一定比同步快,实际只在非阻塞高并发下占优。
    • 认为 WebFlux 能直接替代 MVC,实际生态和团队成本要评估。
    • 认为响应式能随便混阻塞 JDBC,实际必须隔离或换 R2DBC。
    • 认为 onBackpressureBuffer 可以无界,实际会 OOM。
    • 认为 limitRate 越大越好,实际过大会失去背压意义。
    • 认为 subscribe() 后就万事大吉,实际错误和生命周期没人管。
    • 认为响应式不需要监控,实际操作符链路更需要指标和 checkpoint。
    • 认为虚拟线程和 Reactor 是替代关系,实际是不同路线,按下游是否非阻塞选。
    • 认为背压能解决所有过载问题,实际还要限流、熔断、超时和容量评估。
  • 30 秒口述稿:

响应式的核心不是异步,是 Reactive Streams 的背压:下游 request(n) 声明还能消费多少,上游最多发 n 个,整条链路都得守协议。Reactor 用 Flux 表示 0 到 N、Mono 表示 0 到 1,惰性执行,不订阅不跑。线程上 subscribeOn 管上游订阅,publishOn 管下游执行;parallel 跑计算不能阻塞,boundedElastic 跑 JDBC 这类阻塞调用。flatMap 默认并发 256 且不保序,要保序用 concatMap,要限流用 limitRate 和并发参数。错误是终止信号,用 onErrorResume 恢复、retry 重订阅、timeout 取消上游,但取消是协作式的。冷流重复订阅会重跑源,共享用 cache/share。它适合流式、网关、强背压场景,不适合简单 CRUD 和阻塞事务;如果只是把阻塞代码包成 Mono,不如 MVC 加虚拟线程。

  • 3 分钟展开顺序:结论(背压而非异步)→ Reactive Streams 四接口与 request(n) → Flux/Mono 与惰性/冷热流 → publishOn/subscribeOn → 调度器选型 → flatMap/concatMap/limitRate 与并发 → 错误/重试/超时/Context → WebFlux 与 event loop 的阻塞陷阱 → Reactor vs 虚拟线程/CF/结构化并发 → 生产坑与选型收尾。