Async Traits

Async methods in traits are were stabilized in the 1.75 release. This required support for using return-position impl Trait in traits, as the desugaring for async fn includes -> impl Future<Output = ...>.

However, even with the native support, there are some pitfalls around async fn:

  • Return-position impl Trait captures all in-scope lifetimes (so some patterns of borrowing cannot be expressed).

  • Async traits cannot be used with trait objects (dyn Trait support).

The async_trait crate provides a workaround for dyn support through a macro, with some caveats:

  1. use async_trait::async_trait;
  2. use std::time::Instant;
  3. use tokio::time::{sleep, Duration};
  5. #[async_trait]
  6. trait Sleeper {
  7.     async fn sleep(&self);
  8. }
  10. struct FixedSleeper {
  11.     sleep_ms: u64,
  12. }
  14. #[async_trait]
  15. impl Sleeper for FixedSleeper {
  16.     async fn sleep(&self) {
  17.         sleep(Duration::from_millis(self.sleep_ms)).await;
  18.     }
  19. }
  21. async fn run_all_sleepers_multiple_times(
  22.     sleepers: Vec<Box<dyn Sleeper>>,
  23.     n_times: usize,
  24. ) {
  25.     for _ in 0..n_times {
  26.         println!("Running all sleepers...");
  27.         for sleeper in &sleepers {
  28.             let start = Instant::now();
  29.             sleeper.sleep().await;
  30.             println!("Slept for {} ms", start.elapsed().as_millis());
  31.         }
  32.     }
  33. }
  35. #[tokio::main]
  36. async fn main() {
  37.     let sleepers: Vec<Box<dyn Sleeper>> = vec![
  38.         Box::new(FixedSleeper { sleep_ms: 50 }),
  39.         Box::new(FixedSleeper { sleep_ms: 100 }),
  40.     ];
  41.     run_all_sleepers_multiple_times(sleepers, 5).await;
  42. }

This slide should take about 5 minutes.

  • async_trait is easy to use, but note that it’s using heap allocations to achieve this. This heap allocation has performance overhead.

  • The challenges in language support for async trait are too deep to describe in-depth in this class. See this blog post by Niko Matsakis if you are interested in digging deeper. See also these keywords:

  • Try creating a new sleeper struct that will sleep for a random amount of time and adding it to the Vec.