Tokio 流处理:用 Stream trait 处理无限的异步数据序列的工程实践
一、场景引入:无限数据流
大家好,我是一铭。前段时间接了一个需求:实时消费 Kafka 的订单消息流,对每条消息做风控校验、数据增强、格式转换,然后写入 ClickHouse。
这个场景的特点是:数据是无限的、异步的、需要反压控制。你不能把所有数据先读到内存再处理,也不能用简单的 for 循环——因为数据在未来的某个时刻才会到来。
这时候,Tokio 的 Stream trait 就派上用场了。
二、Stream trait 基础
2.1 Stream 是什么
Stream 是异步版的 Iterator。普通迭代器的 next() 是同步的,而 Stream 的 poll_next() 返回 Poll<Option<Item>>,支持异步等待。
Rust 标准库目前还没有 Stream,但 futures 和 tokio-stream 提供了完整的实现:
// 引入 Stream 和 StreamExt
use futures::stream::{Stream, StreamExt};
use tokio_stream::StreamExt as TokioStreamExt;
use std::pin::Pin;
use std::task::{Context, Poll};
2.2 最简单的 Stream:interval
use tokio::time::{interval, Duration};
use tokio_stream::wrappers::IntervalStream;
#[tokio::main]
async fn main() {
// 创建一个每隔 1 秒发射一次的 Stream
let mut stream = IntervalStream::new(interval(Duration::from_secs(1)));
// 取前 5 个事件
while let Some(_) = stream.next().await {
println!("⏰ tick!");
}
}
三、实战:Kafka 到 ClickHouse 的数据管道
3.1 整体架构
我们要实现的数据管道包含以下几个阶段:
- Kafka Source:从 Kafka 消费消息,封装为
Stream - 风控校验:对每条订单做规则检查
- 异步增强:调用外部 API 补充用户画像、商品信息
- 格式转换:转为 ClickHouse 需要的结构
- ClickHouse Sink:批量写入
3.2 构建 Kafka Stream
use rdkafka::consumer::{Consumer, StreamConsumer};
use rdkafka::Message;
/// 将 Kafka 消费者封装为 Stream
/// 每个元素是一条反序列化后的订单消息
fn kafka_stream(
consumer: StreamConsumer,
) -> impl Stream<Item = Result<OrderMessage, PipelineError>> {
// futures::stream::unfold 可以从一个异步函数构建 Stream
futures::stream::unfold(consumer, |consumer| async move {
loop {
match consumer.recv().await {
Ok(message) => {
// 尝试解析 Kafka 消息体为 OrderMessage
match message.payload() {
// payload() 返回 Option<&[u8]>,需要处理 None 情况
Some(payload) => {
match serde_json::from_slice::<OrderMessage>(payload) {
Ok(order) => {
return Some((Ok(order), consumer));
}
Err(e) => {
return Some((Err(PipelineError::Parse(e.to_string())), consumer));
}
}
}
None => continue, // 空消息,跳过
}
}
Err(e) => {
return Some((Err(PipelineError::Kafka(e.to_string())), consumer));
}
}
}
})
}
3.3 风控校验
/// 对订单做风控规则检查
/// 返回标记了风险等级的订单
async fn risk_check(order: OrderMessage) -> Result<CheckedOrder, PipelineError> {
// 规则 1:单笔金额超过 10000 标记为高风险
let risk_level = if order.amount > 10_000.0 {
RiskLevel::High
}
// 规则 2:30 分钟内同一用户下单超过 5 次
else if order.user_recent_count > 5 {
RiskLevel::Medium
} else {
RiskLevel::Low
};
Ok(CheckedOrder {
order,
risk_level,
checked_at: chrono::Utc::now(),
})
}
3.4 异步数据增强(并发控制)
这里是关键——对每条订单调用外部 API 增强数据,需要控制并发数,防止打爆下游服务:
use futures::stream::StreamExt;
/// 并发调用外部 API 增强订单数据
/// 用 buffer_unordered 控制同时进行的请求数
async fn enrich_orders(
stream: impl Stream<Item = Result<CheckedOrder, PipelineError>>,
) -> impl Stream<Item = Result<EnrichedOrder, PipelineError>> {
stream
// then:对每个元素做异步处理
.then(|result| async {
match result {
Ok(checked) => {
// 并发调用两个外部 API
let user_future = fetch_user_profile(checked.order.user_id);
let product_future = fetch_product_info(checked.order.product_id);
// join! 同时发起两个请求,等两个都返回
let (user_result, product_result) =
tokio::join!(user_future, product_future);
match (user_result, product_result) {
(Ok(user), Ok(product)) => Ok(EnrichedOrder {
checked,
user_profile: Some(user),
product_info: Some(product),
}),
(user_err, prod_err) => {
// 任何一方失败就返回错误,但记录日志
eprintln!(
"数据增强失败: user={:?}, product={:?}",
user_err, prod_err
);
Err(PipelineError::Enrichment(
"外部 API 调用失败".into()
))
}
}
}
Err(e) => Err(e),
}
})
// 🔑 关键:最多 10 个并发请求,超过的排队等待
.buffer_unordered(10)
}
3.5 批量写入 ClickHouse
use std::time::Duration;
use tokio::time;
/// 将订单流转为批量写入 ClickHouse
/// 使用 chunks_timeout 实现定时批量提交
async fn batch_write_to_clickhouse(
stream: impl Stream<Item = Result<EnrichedOrder, PipelineError>>,
) {
// 使用 chunks_timeout:
// - 满了 500 条就提交
// - 或者超过 5 秒还没满也提交
let mut chunked = tokio_stream::StreamExt::chunks_timeout(
stream,
500, // 每批最多 500 条
Duration::from_secs(5), // 最多等 5 秒
);
while let Some(batch) = chunked.next().await {
let orders: Vec<_> = batch
.into_iter()
.filter_map(|r| r.ok()) // 只保留成功的
.collect();
if !orders.is_empty() {
// 实际写入 ClickHouse(这里简化)
if let Err(e) = insert_into_clickhouse(&orders).await {
eprintln!("写入 ClickHouse 失败: {}", e);
// 可以考虑写入死信队列做后续重试
}
}
}
}
3.6 组装管道
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// 1. 创建 Kafka 消费者
let consumer: StreamConsumer = create_kafka_consumer()?;
// 2. 构建完整管道
let stream = kafka_stream(consumer);
// 3. 风控校验
let stream = stream.then(|r| async {
match r {
Ok(order) => risk_check(order).await,
Err(e) => Err(e),
}
});
// 4. 异步数据增强(最多 10 并发)
let stream = enrich_orders(stream).await;
// 5. 批量写入 ClickHouse
batch_write_to_clickhouse(stream).await;
Ok(())
}
3.7 实战踩坑:Stream 取消安全与内存泄漏
管道跑起来两天后,监控告警说内存使用一直在涨。排查发现是一个隐蔽的问题——buffer_unordered(10) 在流被提前取消时,已发出的 API 请求并没有被中止,连接资源持续泄漏。
// ❌ 问题代码:timeout 到后 stream 被 drop,飞行的请求泄漏
let stream = enrich_orders(stream).await;
let _ = tokio::time::timeout(
Duration::from_secs(30),
batch_write_to_clickhouse(stream),
).await;
修法:用 tokio::select! + AbortHandle 确保取消时所有子任务都被回收:
// ✅ 安全版本
let handle = tokio::spawn(batch_write_to_clickhouse(stream));
tokio::select! {
result = handle => { /* 正常完成 */ }
_ = tokio::time::sleep(Duration::from_secs(30)) => {
handle.abort();
eprintln!("管道超时,已取消所有飞行中的请求");
}
}
另一个坑:如果下游 ClickHouse 写入慢于上游 Kafka 生产速度,buffer_unordered 的 10 个并发槽会一直占满,内部缓冲区无限增长。解决方法是根据实际吞吐加 throttle 限制流速。这个坑让我认识到:Stream 的反压是协作式的,需要你主动控制流速。 不能假设下游一定能消化所有数据。
四、反压机制详解
Stream 的反压是天然内建的。整个链条的流转逻辑:
当 buffer_unordered 的 10 个并发槽满了,poll_next() 会返回 Poll::Pending,上游(Kafka consumer)自然就不会被调用,实现了端到端的反压。不需要任何额外的队列或信号量。
4.1 实际项目里的反压失效:当 ClickHouse 宕机时
这里有一个容易被忽视的陷阱:chunks_timeout 本身不提供反压。如果 ClickHouse 宕机了,insert_into_clickhouse 超时报错,但 Kafka 消费者仍然在全速拉取消息。buffer_unordered(10) 的并发槽满了就阻塞,但 Kafka consumer 的 auto.offset.commit 还在提交 offset——宕机期间的批处理全部失败 + 丢消息。
解决方案:在 ClickHouse 写入失败时停止提交 Kafka offset,并暂停消费。通过 consumer.pause() 实现端到端的真反压。另外,给 chunks_timeout 的缓冲区设一个上限——如果积压超过 5000 条就报警,人为介入。
压测时建议用 tokio-console 看每个任务的 poll 延迟,一眼就能定位反压卡在哪个环节。
五、总结
这篇文章我们完整地走了一遍用 Tokio Stream 处理无限异步数据流的流程:
- Stream 是异步版的 Iterator,天然支持无限数据序列。
buffer_unordered是控制并发的最佳工具,一行代码搞定限流。chunks_timeout实现定时批量提交,兼顾吞吐和延迟。- 反压是内建的,当消费者处理不过来时,整个链条自动减速,不需要手工控制。
futures::stream::unfold可以从任何异步循环构建 Stream。
Stream 生态还在快速发展,StreamExt 提供的组合子已经非常丰富。掌握 Stream,你就掌握了 Rust 异步数据处理的核心能力。
906



被折叠的 条评论
为什么被折叠?



