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! 展示错误分支如何结束组合等待。

rust
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:?}");
}

预期输出

text
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! 的关键,不是语法偏好,而是失败后是否仍然需要收集其他分支的结果。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

并发等待多个 Future

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通