set_timeout

Crates.ioset_timeout
lib.rsset_timeout
version0.1.4
sourcesrc
created_at2022-07-17 19:03:27.186883
updated_at2022-09-09 11:40:21.228655
descriptionA crate which allows efficiently executing futures after some delay has passed
homepage
repositoryhttps://github.com/MaderNoob/set_timeout
max_upload_size
id627333
size40,503
(MaderNoob)

documentation

README

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

#[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;
}

Usage Tip

You can schedule many timeouts on the scheduler, but you should avoid scheduling futures which take a long time to execute, since such futures can block the scheduler from executing other scheduled timeouts, and may cause other timeouts to execute at a big delay.

If you really need to schedule some future which takes a long time, consider scheduling a future which spawns a new task and then does all the heavy stuff.

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 and the example called multitasking in the examples directory.

Commit count: 15

cargo fmt