How to cancel multiple async tasks in Rust when one fails?

[shield178]

Body

Hi, I’m using Rust with tokio to run multiple async tasks concurrently, but I want a way to cancel all remaining tasks if any task fails.

Here’s my setup:

use tokio::time::{sleep, Duration};
use tokio::task;

#[tokio::main]
async fn main() {
    let tasks = vec![
        task::spawn(async { sleep(Duration::from_secs(3)).await; Ok::<_, &str>("A done") }),
        task::spawn(async { sleep(Duration::from_secs(1)).await; Err::<&str, _>("B failed") }),
        task::spawn(async { sleep(Duration::from_secs(2)).await; Ok::<_, &str>("C done") }),
    ];

    // How can I run all tasks and cancel the remaining ones if any fails?
}

Right now, all tasks run to completion, but I want to stop any remaining tasks immediately when one returns an error.

What’s the best way to handle this in Rust async?

Guidelines

• I have read and understood this category's guidelines before making this post.

[dmitry-nai]

Hi @shield178, could you clarify whether you want the remaining tasks to abort immediately mid-execution, or is it okay if they finish their current step first?

[codeninja115]

Hey @shield178! 😊

I think I understand the issue you’re facing. You want to run multiple async tasks, but stop any remaining ones as soon as one fails. A good way to do this in Rust with Tokio is to use futures::future::select_all.

Here’s a simple example:

use futures::future::select_all;
use tokio::time::{sleep, Duration};
use tokio::task;

#[tokio::main]
async fn main() {
    let tasks: Vec<_> = vec![
        task::spawn(async { sleep(Duration::from_secs(3)).await; Ok::<_, &str>("A done") }),
        task::spawn(async { sleep(Duration::from_secs(1)).await; Err::<&str, _>("B failed") }),
        task::spawn(async { sleep(Duration::from_secs(2)).await; Ok::<_, &str>("C done") }),
    ];

    let mut remaining = tasks;

    while !remaining.is_empty() {
        let (res, _index, rest) = select_all(remaining).await;
        remaining = rest;

        match res {
            Ok(Ok(val)) => println!("Task succeeded: {}", val),
            Ok(Err(err)) => {
                println!("Task failed: {}", err);
                // Cancel all remaining tasks
                for t in remaining {
                    t.abort();
                }
                break;
            }
            Err(join_err) => println!("Task panicked: {:?}", join_err),
        }
    }
}

Explanation:

1. select_all waits for any task in the vector to complete first.
2. When a task finishes, we check if it was an Ok or an Err.
3. If a task returns an error, we call abort() on all remaining tasks to cancel them immediately.
4. This way, no unnecessary tasks continue running after a failure.

Tips:

1. Use tokio::task::spawn for tasks you may need to cancel.
2. abort() cancels the task gracefully, but the task may need to cooperate for full cancellation.
3. This pattern is useful for race conditions, timeout-based work, or critical multi-task pipelines.

Hope this helps! Let me know if you want me to show an example with tasks that panic or hold resources like files — it gets a bit trickier, but it’s doable.