Akka Streams conflate 操作符详解:用聚合消化背压,让快上游与慢下游解耦

原创2026-09-22 12:03:231,962 阅读
文章标签:后端并发编程微服务流处理

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]

两个要点:

  1. 聚合函数签名:aggregate 接收「当前聚合值」与「当前到达的元素」,返回新的聚合值。Scala 中类型约束为 O2 >: Out,即聚合结果类型必须与流入元素类型一致(可以是其超类型)。
  2. 类型不可变:由于聚合函数是 (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)分为三种情况:

  1. 当前无聚合摘要(agg == null):用 seed(elem) 创建初始摘要并计入成本;
  2. 剩余容量不足以容纳新元素(left < cost):将元素暂存为 pending,不参与聚合——这是 batch/batchWeighted 系列容量触发的路径,对 conflate 而言因成本为 0 几乎不会走到;
  3. 否则:执行 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,因为它本质上是"有损但高效"的速率适配器。

登录后查看全文
akka-core