Appearance
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,会把优势直接变成事故。分层要点:
- 先纠正一个误解:响应式不是“用线程池做异步”,而是基于需求的流控。Reactive Streams 规定
Publisher/Subscriber/Subscription三个角色,订阅后下游通过Subscription.request(n)声明需求,上游最多发 n 个onNext,最后以onComplete/onError终止。没有request就没有数据,这是它和CompletableFuture、线程池队列最本质的区别(2.4-13)。 - 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的必要性。 - 背压的端到端语义:背压只有在每一段都遵守协议时才成立。
limitRate(n)把下游请求拆成批次;flatMap(mapper, concurrency, prefetch)用并发度和预取量控制上游请求;concatMap串行保证顺序;onBackpressureBuffer/Drop/Latest/Error是上游不守规矩时的兜底策略。到了 JDBC、阻塞 HTTP 客户端、消息队列这类外部系统,背压传不过去,只能靠有界并发、超时、队列上限和限流兜底。 - 线程模型:publishOn 与 subscribeOn:
subscribeOn影响订阅过程(也就是上游源在哪个调度器上被订阅、请求信号从哪发出),放哪儿都作用于上游,多次使用时最靠近源的那个生效;publishOn影响它下游的onNext/onComplete/onError在哪个调度器执行,可以多次出现、逐段切换。记住口诀:subscribeOn管上游订阅,publishOn管下游执行。 - 调度器选型:
Schedulers.parallel()是固定大小的 CPU 型线程池(默认核数个线程),适合计算,不能阻塞;boundedElastic()是为阻塞调用准备的有界弹性池(默认 10×核数线程、每线程约 10 万任务队列、空闲回收),适合 JDBC/阻塞 SDK;single()单线程;immediate()当前线程;fromExecutor()接自定义池。WebFlux 默认跑在 Reactor Netty 的 event loop 上,线程很少,任何阻塞都会拖垮整个事件循环。 - 操作符与语义:
map同步转换、flatMap异步展开且可能交错、concatMap保序串行、flatMapSequential保序但并发、zip/merge/concat/combineLatest组合、filter/distinct/take/skip过滤、buffer/window/sample/throttle聚合与限速。错误是终止信号:onError之后的正常操作符不再执行;用onErrorReturn/onErrorResume/onErrorMap恢复,用retry/retryWhen(Retry)重订阅,用timeout取消上游(协作式,阻塞调用未必响应)。 - 冷热流与 Context:冷流每个订阅独立执行;热流(
Sinks、ConnectableFlux、publish/share/replay)共享同一份数据,晚订阅者可能错过元素,replay会缓存。Context 是 Reactor 自己的不可变上下文,contextWrite写在链尾、可被上游deferContextual读取;它不传播到 ThreadLocal/MDC,跨线程日志需要Hooks.onEachOperator/Schedulers.onScheduleHook或显式桥接。 - 适用与边界:适合流式数据处理、SSE/WebSocket、API 网关、高并发 IO 聚合、需要背压的管道;不适合简单 CRUD、JPA/JDBC 阻塞链路、复杂事务、CPU 密集计算和调试能力不足的团队。响应式的收益来自“少量线程 + 非阻塞 + 背压”,代价是学习曲线、堆栈难读、调试和排障成本高;如果只是把阻塞代码搬进
Mono,不如用 Spring MVC + 虚拟线程(2.4-11)。选型要看下游是否真的支持非阻塞,而不是看“响应式”这个词。
- 先纠正一个误解:响应式不是“用线程池做异步”,而是基于需求的流控。Reactive Streams 规定
图/流程:
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 ───────► 取消上游并发出 TimeoutExceptionjava
// 非阻塞聚合(示意)
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做背压单测。
- Reactive Streams 1.0.x 规范:
Flux 与 Mono 对比:
| 维度 | Flux<T> | Mono<T> |
|---|---|---|
| 元素个数 | 0..N | 0..1 |
| 典型场景 | 列表、流、SSE、消息 | 单次 RPC、单条查询、命令 |
| 空结果 | onComplete 无元素 | Mono.empty() |
| 转换 | map/flatMap/filter | map/flatMap |
| 聚合 | collectList/collectMap/reduce | then/zipWith |
| 订阅 | subscribe 后可接收多个 | 最多一个 |
- publishOn 与 subscribeOn 对比:
| 维度 | subscribeOn | publishOn |
|---|---|---|
| 影响范围 | 订阅过程与上游请求信号 | 下游的 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) | CompletableFuture | StructuredTaskScope |
|---|---|---|---|---|
| 编程模型 | 声明式流、操作符 | 同步阻塞式 | 回调/链式 | 同步 + 子任务树 |
| 背压 | 内建(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 |
| 日志没有 traceId | Context 不传播到 MDC | onScheduleHook/onEachOperator 桥接 |
| 错误后整条链静默 | onError 是终止信号且未处理 | onErrorResume/onErrorMap + 监控 |
retry 放大故障 | 无退避、无限重试 | Retry.backoff + 上限 + 熔断 |
timeout 没生效 | 下游阻塞不响应取消 | 下游客户端超时 + 有界并发 |
| 内存持续上涨 | 无界 buffer、replay 缓存过大 | 有界队列、限制缓存、及时 dispose |
| 顺序错乱 | flatMap 并发交错 | concatMap 或 flatMapSequential |
| 订阅无人管理 | 手动 subscribe() 后丢失 | 交给框架,或用 Disposable 管理 |
深挖点(面试官常追的 6 个):
- 背压到底是什么:它是需求驱动的流控协议:下游
request(n)声明还能消费多少,上游最多发 n 个。它和“有界队列 + 拒绝策略”不同:队列是缓冲,背压是让生产端降速。端到端成立的前提是每一段都实现Publisher协议;一旦进入阻塞 JDBC/HTTP,背压就断了,只能用并发度、超时和队列上限做近似。 - publishOn 与 subscribeOn 的线程语义:
subscribeOn切换的是订阅动作发生的调度器,影响上游源在哪个线程被订阅和请求;publishOn切换的是信号向下游传递的调度器。放在链中间时,publishOn只影响它下游;subscribeOn无论放哪儿都作用于上游,多次出现时最靠近源的生效。实际排障时先看“源在哪个线程跑”,再看“下游回调在哪个线程跑”。 - flatMap 的并发、顺序与背压:
flatMap会同时订阅最多concurrency个内层 Publisher,向上游预取prefetch个元素,结果按完成顺序交错;concatMap串行、保序但吞吐低;flatMapSequential并发执行但按源顺序发射。并发度太大打满下游,太小浪费吞吐;limitRate控制请求批次,避免一次拉太多。 - 错误、重试、超时的语义:
onError是终止信号,流结束后不会再有元素;onErrorResume切换到备用 Publisher,onErrorMap转换异常类型,retry/retryWhen重新订阅(冷流会重新执行源,注意幂等),timeout在超时后取消上游并发出TimeoutException。取消是协作式的:阻塞调用如果不在可中断点,未必立刻停下。 - 冷热流与 Context:冷流每次订阅独立执行,适合“一次请求一次调用”;重复订阅会重复执行,需要
cache/share。热流用Sinks/ConnectableFlux广播,晚订阅者可能错过数据,replay会缓存。Context 是不可变映射,contextWrite写在链尾、对上游可见;它不进入 ThreadLocal,日志 MDC 要额外桥接。 - 响应式适合与不适合的边界:适合流式数据、网关、SSE/WebSocket、非阻塞客户端、需要端到端背压的管道;不适合阻塞 JDBC/JPA、复杂事务、简单 CRUD、CPU 密集和团队调试能力不足的场景。Spring MVC + 虚拟线程在阻塞 IO 上往往更简单;WebFlux 的价值在“少量线程支撑高并发 + 流式 + 背压”,而不是“响应式一定更快”。
- 背压到底是什么:它是需求驱动的流控协议:下游
追问链:
- 什么是响应式编程? → 基于数据流和变化传播的编程模型,Reactor 里体现为 Publisher/Subscriber 的异步流。
- 响应式的核心是异步吗? → 不是,核心是 Reactive Streams 的背压协议。
- Reactive Streams 有哪几个接口? →
Publisher/Subscriber/Subscription/Processor。 - 背压怎么工作? → 下游
request(n)声明需求,上游最多发 n 个onNext。 - 为什么需要背压? → 生产快于消费时避免无界缓冲、OOM 和雪崩。
- Flux 和 Mono 区别? → Flux 0..N,Mono 0..1。
- 不订阅会执行吗? → 不会,Reactor 是惰性的。
- 冷流和热流区别? → 冷流每个订阅独立执行,热流共享数据。
- 重复订阅会怎样? → 冷流会重复执行源,可能重复调用下游。
- 怎么避免重复执行? →
cache/share、复用同一个 Publisher、Sinks。 just和defer区别? →just装配时求值,defer每次订阅才创建源。fromCallable有什么用? → 包装阻塞调用并捕获异常转成onError。- publishOn 干什么? → 切换它下游信号执行的调度器。
- subscribeOn 干什么? → 切换订阅/请求信号发生的调度器,影响上游。
- 两者能互换吗? → 不能,作用方向不同。
- 多个 subscribeOn 谁生效? → 最靠近源的那个。
- parallel 调度器适合什么? → CPU 计算,不能阻塞。
- boundedElastic 适合什么? → 阻塞 IO/JDBC,有界弹性池。
- WebFlux 默认在哪个线程? → Reactor Netty event loop。
- 在 event loop 里 block 会怎样? → 拖垮事件循环,吞吐骤降。
- flatMap 会保序吗? → 不保序,按完成顺序交错。
- 怎么保序? →
concatMap或flatMapSequential。 - flatMap 默认并发多少? → 256(具体按版本)。
- 怎么限制并发? → 显式传
concurrency/prefetch,配合limitRate。 - limitRate 干什么? → 把请求拆成批次,控制预取。
- 上游不守背压怎么办? →
onBackpressureBuffer/Drop/Latest/Error。 - buffer 有什么风险? → 无界缓冲 OOM。
- onError 之后还能继续吗? → 不能,onError 是终止信号。
- 怎么恢复错误? →
onErrorReturn/onErrorResume/onErrorMap。 - retry 会重新执行源吗? → 会重新订阅,冷流会重跑。
- retry 有什么风险? → 无退避会放大故障,需
Retry.backoff+ 熔断。 - timeout 会取消上游吗? → 会发出取消,但阻塞调用未必响应。
- Context 是什么? → Reactor 的不可变上下文,随流传播。
- contextWrite 写在哪? → 链尾,对上游可见。
- Context 会进 ThreadLocal 吗? → 不会,MDC 需桥接。
- 怎么在日志里带 traceId? →
onScheduleHook/onEachOperator桥接 Context 与 MDC。 - Sinks 是什么? → 手动创建热流的 API,支持单播/多播/replay。
- replay 有什么风险? → 缓存无界会占内存。
- 响应式能做事务吗? → 可以配 R2DBC 的
ReactiveTransactionManager,但不能混阻塞 JDBC。 - 响应式和虚拟线程怎么选? → 流式/背压/网关用 Reactor;阻塞 IO/CRUD 用虚拟线程更简单。
- 响应式和 CompletableFuture 怎么选? → 简单扇出用 CF;流式组合、背压、取消传播用 Reactor。
- 响应式一定更快吗? → 不一定,只在高并发 IO + 非阻塞链路下体现优势。
- 怎么调试响应式? →
checkpoint()、Hooks.onOperatorDebug()(开发期)、StepVerifier、日志操作符。 - 怎么测试背压? →
StepVerifier和TestPublisher精确控制请求量。 - 面试怎么总结? → 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 换轻量编排,代价是无背压。
- WebFlux 接口里调用了阻塞 JDBC,压测时 RT 飙升、event loop 被打满;改为 R2DBC,或把阻塞调用切到
易错点:
- 认为响应式就是异步线程池,实际核心是背压协议。
- 认为
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/结构化并发 → 生产坑与选型收尾。