Waitgroup in tokio!

[ab-basit]

Can we have WaitGroup like feature in tokio?

[Darksonn]

The standard use-case for WaitGroup in go is to wait for a set of tasks to finish, but the best way to do that in Tokio is to store a Vec<JoinHandle<T>> and use a loop:

let mut join_handles = Vec::new();
for i in 0..10 {
    join_handles.push(tokio::spawn(my_async_fn(i)));
}
for jh in join_handles {
    jh.await.unwrap();
}

You can also use a JoinSet instead of the vector.

[ab-basit]

@Darksonn understood! but there could be complex workflow where we want to make sure all tasks are completed.
I was thinking to have something like this which allows to clone the Taskgroup and pass around, Finally wait on taskgroup , say in shutdown method where we want every task to complete before shutting down.

[Noah-Kennedy]

I feel like this calls for a new method in JoinSet.

[aaronriekenberg]

There is a library called awaitgroup that might be useful: https://crates.io/crates/awaitgroup

I am not the author, but I have used this in the past. Has an interface similar to sync.WaitGroup in go.

[laizy]

You can also try https://github.com/laizy/waitgroup-rs I made 3 years ago. It is tiny and performant :

1. resuse the Arc's refcount to track the tasks instead another AtomicUsize;
2. lock free, do not use any Mutex in the implementation;
3. support nested tasks;

[Nugine]

A newer solution:
https://docs.rs/tokio-util/latest/tokio_util/task/task_tracker/struct.TaskTracker.html

[xrayw]

In addition to JoinSet and TaskTracker. we have another way to do it.

let (tx, rx) = mpsc::sync_channel::<i32>(1);
        
for i in 1..=5 {
    let tx1 = tx.clone();
    spawn(|| {
        // ...
        drop(tx1)
    });
}

drop(tx);

// it will block until all the senders disconnected, then return Err
let _ = rx.recv();