Join

A join operation waits until all of a set of futures are ready, and returns a collection of their results. This is similar to Promise.all in JavaScript or asyncio.gather in Python.

  1. use anyhow::Result;
  2. use futures::future;
  3. use reqwest;
  4. use std::collections::HashMap;
  6. async fn size_of_page(url: &str) -> Result<usize> {
  7.     let resp = reqwest::get(url).await?;
  8.     Ok(resp.text().await?.len())
  9. }
  11. #[tokio::main]
  12. async fn main() {
  13.     let urls: [&str; 4] = [
  14.         "https://google.com",
  15.         "https://httpbin.org/ip",
  16.         "https://play.rust-lang.org/",
  17.         "BAD_URL",
  18.     ];
  19.     let futures_iter = urls.into_iter().map(size_of_page);
  20.     let results = future::join_all(futures_iter).await;
  21.     let page_sizes_dict: HashMap<&str, Result<usize>> =
  22.         urls.into_iter().zip(results.into_iter()).collect();
  23.     println!("{page_sizes_dict:?}");
  24. }

This slide should take about 4 minutes.

Copy this example into your prepared src/main.rs and run it from there.

  • For multiple futures of disjoint types, you can use std::future::join! but you must know how many futures you will have at compile time. This is currently in the futures crate, soon to be stabilised in std::future.

  • The risk of join is that one of the futures may never resolve, this would cause your program to stall.

  • You can also combine join_all with join! for instance to join all requests to an http service as well as a database query. Try adding a tokio::time::sleep to the future, using futures::join!. This is not a timeout (that requires select!, explained in the next chapter), but demonstrates join!.