Rust / 系统课时
并发等待多个 Future
并发等待多个 Future
连续写多个 .await 会先完成前一个 Future,再开始推进后一个;而 join! 与 try_join! 可以在同一个任务中并发轮询多个 Future。本篇通过一个可运行示例比较三种写法,并明确结果聚合、错误传播以及“并发不等于多线程并行”的边界。
学习目标
- 区分顺序
.await与并发等待对总等待时间的影响 - 使用
tokio::join!聚合多个 Future 的输出 - 使用
tokio::try_join!在任一分支失败时提前返回错误
顺序 await 为什么会串行
表达式 first().await 没有完成之前,当前异步函数不会执行到下一行,因此第二个 Future 甚至还没有被创建和轮询。两个彼此独立、主要等待 I/O 或定时器的操作如果这样书写,总等待时间通常接近两段等待时间之和。
join! 会同时持有多个 Future,并在当前任务被唤醒时推进它们。它不会自动创建 Tokio 任务,也不会把分支分配到多个线程;如果某个分支在一次轮询里做了很长的同步计算,仍然可能拖慢其他分支。
用 join! 并发聚合结果
下面的完整示例基于 Tokio 1.x,项目依赖需包含 tokio = { version = "1", features = ["full"] }。两个独立操作各等待 300 ms:顺序版本被 450 ms 超时截断,而 join! 版本能在同一时间预算内完成。示例随后用 try_join! 展示错误分支如何结束组合等待。
use std::time::Duration;
use tokio::time::{sleep, timeout};
async fn delayed(name: &'static str, delay: Duration) -> &'static str {
sleep(delay).await;
name
}
async fn may_fail(
name: &'static str,
delay: Duration,
fail: bool,
) -> Result<&'static str, &'static str> {
sleep(delay).await;
if fail {
Err("boom")
} else {
Ok(name)
}
}
#[tokio::main]
async fn main() {
let sequential = timeout(Duration::from_millis(450), async {
let first = delayed("alpha", Duration::from_millis(300)).await;
let second = delayed("beta", Duration::from_millis(300)).await;
(first, second)
})
.await;
println!("sequential timed out: {}", sequential.is_err());
let concurrent = timeout(Duration::from_millis(450), async {
tokio::join!(
delayed("alpha", Duration::from_millis(300)),
delayed("beta", Duration::from_millis(300))
)
})
.await
.expect("concurrent waits should finish before timeout");
println!("join results: {}, {}", concurrent.0, concurrent.1);
let tried = tokio::try_join!(
may_fail("left", Duration::from_millis(200), false),
may_fail("right", Duration::from_millis(100), true)
);
println!("try_join result: {tried:?}");
}预期输出
sequential timed out: true
join results: alpha, beta
try_join result: Err("boom")这个例子把时间差转化成可验证的超时结果,因此不依赖打印具体毫秒数。正常环境中,300 ms 的并发等待会明显低于 450 ms,而两个 300 ms 的顺序等待无法在该时间预算内完成。
join! 与 try_join! 的边界
join! 会等待所有分支结束,并把每个分支的原始输出组成元组;如果分支返回 Result,错误值也只是元组里的普通元素,不会触发提前返回。它适合“无论成功失败都要收齐结果”的组合。
try_join! 面向返回 Result 的分支:所有分支成功时得到 Ok((...)),任一分支先返回错误时,组合立即返回该错误,尚未完成的分支随组合 Future 被丢弃,不再由它继续推进。它适合“一项失败就没有继续等待价值”的请求组合,但这不等于自动撤销已经发生的外部副作用。
当多个操作相互独立且主要等待 I/O 时,优先考虑并发等待;当后一步依赖前一步结果时,顺序 .await 才是正确表达。选择 join! 还是 try_join! 的关键,不是语法偏好,而是失败后是否仍然需要收集其他分支的结果。