Akka Streams conflate 操作符详解:用聚合消化背压,让快上游与慢下游解耦
Akka Streams conflate 操作符详解:用聚合消化背压,让快上游与慢下游解耦
导读
在 Akka Streams 中,当上游生产速率高于下游消费速率时,直接施加背压会导致上游阻塞,甚至引发吞吐抖动。conflate 操作符提供了另一种优雅的解决方案:在背压期间将到达的元素与当前聚合值(summary)折叠为一个新值,待下游恢复消费时一次性下发。本文以 conflate.md 为主体,结合 Akka 源码中的 Batch GraphStage 实现与 FlowConflateSpec.scala 测试用例,深入讲解 conflate 的语义、签名、用法、底层原理及 conflateWithSeed 的差异,读完即可在项目中正确选用此类"速率变换"操作符。
一、conflate 解决什么问题
conflate 的核心语义一句话概括:在下游存在背压的期间,把陆续到达的元素与一个聚合摘要(summary)合并,从而允许较慢的下游不被快速上游拖垮。
它属于 Akka Streams 文档中分类的 @refBackpressure aware operators,其典型场景是:上游数据源(如传感器、日志流、股票行情)持续高速产生元素,且无法或不愿被背压信号减速;下游消费者(如写入数据库、渲染 UI)处理速度较慢。此时与其让上游停滞等待,不如在背压窗口内把元素"折叠"成摘要,例如求和、求平均值、统计数量,待下游就绪后一次下发。
一个直观的数值例子(文档原例):假设下游正在背压,此时上游依次到达 1、10、100,随后背压解除——conflate 并不会依次补发这三个元素,而是把三者合并为 111(即 1 + 10 + 100)一次性发射给下游。这样上游可以持续生产,下游收到的元素总量大幅减少,且每个元素都携带了背压期间所有信息的聚合结果。
二、API 签名
conflate 同时定义在 Source 与 Flow 上,Scala 与 Java 两种 DSL 均有对应版本:
Scala(scaladsl),定义于 scaladsl/Flow.scala:
def conflateO2 >: Out => O2): Repr[O2]
Java(javadsl),定义于 javadsl/Source.scala 与 javadsl/Flow.scala:
def conflate(aggregate: function.Function2[Out, Out, Out]): javadsl.Source[Out, Mat]
两个要点:
- 聚合函数签名:
aggregate接收「当前聚合值」与「当前到达的元素」,返回新的聚合值。Scala 中类型约束为O2 >: Out,即聚合结果类型必须与流入元素类型一致(可以是其超类型)。 - 类型不可变:由于聚合函数是
(O2, O2) => O2,输入输出同一类型。若希望聚合后得到不同类型(例如把多个元素聚合成List、统计结构、字符串摘要),需要使用conflateWithSeed(见下文第四节)。
此外,SubSource 与 SubFlow 上也提供同样的 conflate 方法,可在 groupBy 产生的子流中使用。
三、完整示例:Scala 与 Java
文档中的可运行示例位于测试源码中,完整代码见 Conflate.scala 与 SourceOrFlow.java。
Scala 示例:
import scala.concurrent.duration._
Source
.cycle(() => List(1, 10, 100, 1000).iterator)
.throttle(10, per = 1.second) // faster upstream
.conflate((acc, el) => acc + el) // acc: Int, el: Int
.throttle(1, per = 1.second) // slow downstream
Java 示例:
Source.cycle(() -> Arrays.asList(1, 10, 100).iterator())
.throttle(10, Duration.ofSeconds(1)) // fast upstream
.conflate((Integer acc, Integer el) -> acc + el)
.throttle(1, Duration.ofSeconds(1)); // slow downstream
示例结构拆解:
Source.cycle(...):无限循环产生1, 10, 100, 1000序列,模拟永不枯竭的快速生产者;- 上游
throttle(10, per = 1.second):每秒放行 10 个元素,制造"快速上游"; conflate((acc, el) => acc + el):聚合函数为求和,acc 是当前累计值,el 是新到达元素;- 下游
throttle(1, per = 1.second):每秒只消费 1 个元素,制造"慢速下游"。
由于下游每秒只取一个元素,而上游每秒到达 10 个,背压期间其余 9 个元素会被求和折叠进当前摘要。最终下游收到的将是 1、11(1+10)、111(1+10+100)、1111(1+10+100+1000)…… 之类逐步累加的结果,而不是原始的元素序列——这正是"速率解耦"的体现。
四、conflate 与 conflateWithSeed:类型能否变化的取舍
conflate 的聚合函数 (O2, O2) => O2 要求摘要与元素同类型。当需要聚合出不同类型的结果时,应改用 conflateWithSeed,其定义同样位于 scaladsl/Flow.scala:
def conflateWithSeedS(aggregate: (S, Out) => S): Repr[S]
seed:以第一个未被消费的元素为起点,构造初始聚合状态S;aggregate:将当前聚合状态S与待处理元素Out合并为新的状态S。
文档配套示例(Scala)使用自定义类型 Summed 演示了类型变换:
case class Summed(i: Int) {
def sum(other: Summed) = Summed(this.i + other.i)
}
Source
.cycle(() => List(1, 10, 100, 1000).iterator)
.throttle(10, per = 1.second) // faster upstream
.conflateWithSeed(el => Summed(el))((acc, el) => acc.sum(Summed(el))) // (Summed, Int) => Summed
.throttle(1, per = 1.second) // slow downstream
对应的 Java 版本定义于 SourceOrFlow.java,使用 Summed::new 作为 seed、(Summed acc, Integer el) -> acc.sum(new Summed(el)) 作为聚合函数。
从源码看,两者是"特化与泛化"的关系:conflate 直接以恒等函数作为 seed 委托给 conflateWithSeed 实现,见 scaladsl/Flow.scala:
def conflateO2 >: Out => O2): Repr[O2] =
conflateWithSeedO2(aggregate)
这也解释了为什么 conflate 要求类型不变——它本质上是 conflateWithSeed 在 seed 为恒等函数时的特例。
五、底层实现原理:Batch GraphStage
conflate 与 conflateWithSeed 最终都编译为同一个内部 GraphStage——Batch,见 impl/fusing/Ops.scala:
@InternalApi private[akka] final case class BatchIn, Out => Out)
extends GraphStage[FlowShape[In, Out]]
conflate 传入的具体参数是 Batch(1L, ConstantFun.zeroLong, seed, aggregate):
max = 1L:聚合容量上限为 1,即"最多维护一个聚合摘要";costFn = ConstantFun.zeroLong:每个元素的成本恒为 0,意味着聚合永不因成本超限而提前触发 flush;seed/aggregate:即用户提供的种子与聚合函数。
Batch 的逻辑状态包含三个字段(Ops.scala):
agg:当前聚合摘要(可能为 null 表示空);left:剩余可聚合容量(此处恒为max - 已消耗成本,因成本为 0,通常不会触发容量分支);pending:暂存的下一个待处理元素。
核心的 onPush 处理逻辑(Ops.scala)分为三种情况:
- 当前无聚合摘要(
agg == null):用seed(elem)创建初始摘要并计入成本; - 剩余容量不足以容纳新元素(
left < cost):将元素暂存为pending,不参与聚合——这是batch/batchWeighted系列容量触发的路径,对conflate而言因成本为 0 几乎不会走到; - 否则:执行
agg = aggregate(agg, elem)折叠进摘要并扣减成本。
flush()(Ops.scala)在 isAvailable(out) 时被调用:先把当前摘要 agg push 给下游,随后如果存在 pending 则用 seed(pending) 开启新一轮聚合,否则清空 agg。onUpstreamFinish(Ops.scala)在无聚合摘要时直接 completeStage(),否则等待下游拉取后再收尾——这正是"上游完成时,若仍有未发射的摘要则先发射摘要再完成"的行为。
值得注意的是 Batch 对异常的处理:seed 与 aggregate 抛出的异常会交给 SupervisionStrategy 的 decider 决定 Stop/Restart/Resume(见 Ops.scala),并通过 restartState() 清空聚合状态。这意味着 conflate 遵循 ActorAttributes.SupervisionStrategy 属性,用户可以用 Supervision.restartingDecider 或 resumingDecider 控制异常行为。此外,算子被赋予 DefaultAttributes.conflate 名称(见 impl/Stages.scala),并在聚合函数上记录 SourceLocation 便于调试。
六、更复杂的速率变换:统计摘要与随机采样
conflate 的聚合函数完全由用户定义,因此可以承载任意归约逻辑。Akka 文档的 stream-rate.md 一节提供了两个高价值变体,示例代码见 RateTransformationDocSpec.scala。
示例 1:聚合为标准差/均值/计数三元组
val statsFlow = Flow[Double].conflateWithSeed(immutable.Seq(_))(_ :+ _).map { s =>
val μ = s.sum / s.size
val se = s.map(x => pow(x - μ, 2))
val σ = sqrt(se.sum / se.size)
(σ, μ, s.size)
}
背压期间到达的所有元素被累积成一个 Seq,下游取走时一次性计算该批次的标准差 σ、均值 μ 与元素数量 s.size。该例说明 conflate 可以把"元素流"变换为"统计摘要流",流首速率可以远高于流尾速率,速率被彻底解耦。
示例 2:随机采样(丢弃部分元素)
val p = 0.01
val sampleFlow = Flow[Double]
.conflateWithSeed(immutable.Seq(_)) {
case (acc, elem) if Random.nextDouble() < p => acc :+ elem
case (acc, _) => acc
}
.mapConcat(identity)
当生产者过快时,不再把每个元素都纳入摘要,而是以概率 p = 0.01 随机保留元素,其余直接丢弃。聚合函数返回原样 acc 即可实现"有损采样",最后用 mapConcat(identity) 把收集到的元素重新摊平为流。
七、Reactive Streams 语义
conflate 的 Reactive Streams 语义(文档 callout 及 scaladoc 均有记载):
- emits(发射):当下游停止背压且存在可用的聚合摘要时;
- backpressures(背压):当聚合函数无法跟上到达的元素时——注意 scaladoc 中写作 "backpressures when never",实际含义是
conflate自身几乎不会对上游施加背压,元素总是被立即消费并折叠进摘要,唯一的隐式约束是聚合函数本身的执行速度; - completes(完成):当上游完成时(若仍有未发射的摘要,会先发射摘要再完成);
- cancels(取消):当下游取消订阅时。
与之对比,同属"缓冲/聚合"家族的 batch 与 batchWeighted 则会在达到 max 容量时对上游产生真实背压(见 scaladsl/Flow.scala 的 scaladoc:"backpressures when there are max batched elements and 1 pending element and downstream backpressures")。这正是 conflate(无限折叠)与 batch(有上限折叠)的本质区别。
八、测试验证:行为边界一目了然
FlowConflateSpec.scala 用 TestPublisher/TestSubscriber 精确验证了 conflate 的行为边界,可作为理解语义的权威依据:
- 无速率差时原样透传(L28-L62):
request(1)与sendNext(i)交替进行时,conflateWithSeed与简单conflate都逐个透传元素,不会合并或重复元素; - 下游静默时聚合(L64-L98):连续发送
1..100而不 request,下游expectNoMessage,一旦request(1)便收到5050(即 1 到 100 之和),证明背压窗口内的所有元素被折叠为一个摘要; - 变速率链路上求和守恒(L100-L118):对
1 to 1000做求和聚合,无论中间map如何随机 sleep,最终runFold结果恒为500500——求和是结合律运算,聚合顺序不影响结果; - 上游更慢时正常背压(L120-L151):上游慢于下游时
conflate退化为直通,不引入额外延迟,且两个连续元素在背压窗口内会合并(如3、4合并为7); - 监督策略(L161-L285):
seed或aggregate抛出异常时,restartingDecider会重置聚合状态并丢弃失败元素,resumingDecider则仅丢弃触发异常的元素、保留已聚合的其余元素。
九、选型建议与延伸阅读
| 需求 | 推荐操作符 |
|---|---|
| 下游慢,元素同类型聚合(求和/最大值等) | conflate |
| 下游慢,聚合结果类型需变化(统计结构、List 等) | conflateWithSeed |
| 聚合有容量上限,超限需对上游背压 | batch / batchWeighted |
| 上游慢,需要为下游补充/填充元素 | extrapolate / expand |
conflate 是"速率变换"(Rate transformation)家族中偏重"合并压缩"的一员,与其镜像的 expand/extrapolate(偏重"拉伸补充")共同构成 Akka Streams 处理生产者-消费者速率失衡的两套手段,详见 stream-rate.md。更多 API 细节还可参考 conflateWithSeed 文档页,以及 scaladsl 中与之并列的 limit、limitWeighted 等操作符(见 scaladsl/Flow.scala 的 See also 注释)。
实践建议:当业务可以接受"背压期间的信息以摘要形式呈现"(如监控指标、计数、最近状态)时,优先考虑 conflate;当摘要会丢弃业务关键细节时,应改用有界缓冲或 batch 并配合适当的丢弃策略;切勿在需要逐元素保真的场景使用 conflate,因为它本质上是"有损但高效"的速率适配器。