tokio::try_join!搭配tokio::spawn无法提前返回问题求助

你当前的代码逻辑里，tokio::spawn返回的JoinHandle只有在任务被取消或发生panic时才会输出Err；而method1/2/3自身返回的错误，会被包裹在JoinHandle的Ok结果中（也就是handle1_ret的类型是Result<Result<_, _>, JoinError>）。

这就导致tokio::try_join!会一直等待所有JoinHandle执行完毕，完全无视内部方法的错误，自然不会提前返回。

根据是否需要独立任务，提供三种实现方式：

方式一：无需独立任务时直接用try_join! #

如果不需要把method1/2/3放到独立的Tokio任务中，直接用try_join!包裹异步方法调用即可。此时只要任一方法返回Err，try_join!会立即终止等待并返回该错误，不会继续等待其他方法完成。

#[tokio::main]
async fn main() -> io::Result<()> {
    // ...

    // 直接将异步方法传入try_join!
    let (res1, res2, res3) = tokio::try_join!(method1(), method2(), method3)?;

    // 处理各方法结果
    match res1 {
        Ok(_) => info!("handle1 closed"),
        Err(e) => error!("handle1 failed: {}", e),
    }
    match res2 {
        Ok(_) => info!("handle2 closed"),
        Err(e) => error!("handle2 failed: {}", e),
    }
    match res3 {
        Ok(_) => info!("handle3 closed"),
        Err(e) => error!("handle3 failed: {}", e),
    }

    Ok(())
}

方式二：需要独立任务时用select!终止其他任务 #

如果必须将方法放到独立Tokio任务中，用tokio::select!监听第一个完成的任务，一旦某个任务返回错误，立即调用其他任务的abort()方法终止它们，然后退出流程。

#[tokio::main]
async fn main() -> io::Result<()> {
    // ...

    let handle1 = tokio::spawn(async move { method1().await });
    let handle2 = tokio::spawn(async move { method2().await });
    let handle3 = tokio::spawn(async move { method3().await });

    // select!会等待第一个完成的任务分支
    tokio::select! {
        res1 = handle1 => {
            handle2.abort();
            handle3.abort();
            match res1? {
                Ok(_) => info!("handle1 closed"),
                Err(e) => error!("handle1 failed: {}", e),
            }
        }
        res2 = handle2 => {
            handle1.abort();
            handle3.abort();
            match res2? {
                Ok(_) => info!("handle2 closed"),
                Err(e) => error!("handle2 failed: {}", e),
            }
        }
        res3 = handle3 => {
            handle1.abort();
            handle2.abort();
            match res3? {
                Ok(_) => info!("handle3 closed"),
                Err(e) => error!("handle3 failed: {}", e),
            }
        }
    }

    Ok(())
}

方式三：用JoinSet管理动态任务（Tokio 1.21+） #

如果任务数量不固定，推荐用Tokio提供的JoinSetAPI，它能更灵活地管理多个任务。一旦有任务返回错误，调用abort_all()终止所有剩余任务即可。

#[tokio::main]
async fn main() -> io::Result<()> {
    // ...

    let mut join_set = tokio::task::JoinSet::new();

    // 添加任务到JoinSet
    join_set.spawn(async move { method1().await });
    join_set.spawn(async move { method2().await });
    join_set.spawn(async move { method3().await });

    while let Some(task_res) = join_set.join_next().await {
        match task_res? {
            Ok(_) => info!("任务执行完成"),
            Err(e) => {
                error!("任务执行失败: {}", e);
                // 终止所有剩余任务
                join_set.abort_all();
                break;
            }
        }
    }

    Ok(())
}

内容的提问来源于stack exchange，提问作者Walk Anywhere