set_timeout

This crate allows executing futures after a certain delay, similar to how setTimeout works in js. The scheduling of a future can be cancelled as long as the future wasn't already executed, by using a CancellationToken.

This crate uses a scheduler which allows running an unlimited number of delayed futures using just a single tokio task, in contrast to many crates which spawn a new task for each set timeout call. This uses less memory and should be more performant.

Please note that this crate can only be used in the context of a tokio runtime.

Example

```rust

[tokio::main]

async fn main() { let scheduler = TimeoutScheduler::new(None);

let start = Instant::now();

// schedule a future which will run after at least 1.234 seconds from now.
scheduler.set_timeout(Duration::from_secs_f32(1.234), async move {
    let elapsed = start.elapsed();

    assert!(elapsed.as_secs_f32() > 1.234);

    println!("elapsed: {:?}", elapsed);
});

// make sure that the main task doesn't end before the timeout is executed, because if the main
// task returns the runtime stops running.
tokio::time::sleep(Duration::from_secs(2)).await;

} ```

Sharing The Scheduler

The timeout scheduler can be shared between multiple tasks, by storing it in an Arc, or by storing it in a global variable using the lazy_static crate. For an example of this, check out the example called global_variable in the examples directory.