rustrust-tokio

`tokio::try_join!` on a vector of `JoinHandle`s


New to Rust. I want to wait for the following async tasks to finish:

let _ = tokio::try_join!(fetch_handle, evaluate_handles[0], evaluate_handles[1], evaluate_handles[2], evaluate_handles[3]);

Is there a way to do this without hard-coding each item in evaluate_handles? evaluate_handles is a Vec<JoinHandle<()>>, and fetch_handle is just a single JoinHandle<()>


Solution

  • In general, you can use TryJoinAll to do try_join! on an iterator of tasks (futures):

    use futures::future::TryJoinAll;
    let join_evaluate_handles = evaluate_handles.into_iter().collect::<TryJoinAll<_>>();
    

    In your case, all the join handles have the same type, so you could just construct an iterator that contains them all:

    evaluate_handles.into_iter()
        .chain(once(fetch_handle))
        .collect::<TryJoinAll<_>>()
        .await
    

    If they weren't the same type, you would combine TryJoinAll and try_join!:

    try_join!(fetch_handle, join_evaluate_handles /* from above */)
    

    Note, however, that I'm not sure it's super meaningful to use try_join here anyway. try_join's main point is that it returns immediately if one of the futures errors. But your futures are JoinHandles, and those only error when the spawned task panics: Playground Now, panicking in a spawned future makes tokio print an ugly error message, and you want to avoid that in general. The only practical use-case for using try_join here I can think of is aborting your application if a panic happens somewhere. But I think there's less hassle-full ways of doing this.


    One more note: If you're using TryJoinAll or FuturesUnordered, there's no real need to tokio::spawn your tasks in the first place.