Future returned by sleep and sleep_until.

This type does not implement the Unpin trait, which means that if you use it with select! or by calling poll, you have to pin it first. If you use it with .await, this does not apply.

Examples

Wait 100ms and print "100 ms have elapsed".

use tokio::time::{sleep, Duration};

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
sleep(Duration::from_millis(100)).await;
println!("100 ms have elapsed");
# }

Use with select!. Pinning the Sleep with tokio::pin! is necessary when the same Sleep is selected on multiple times.

use tokio::time::{self, Duration, Instant};

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let sleep = time::sleep(Duration::from_millis(10));
tokio::pin!(sleep);

loop {
    tokio::select! {
        () = &mut sleep => {
            println!("timer elapsed");
            sleep.as_mut().reset(Instant::now() + Duration::from_millis(50));
        },
    }
}
# }

Use in a struct with boxing. By pinning the Sleep with a Box, the HasSleep struct implements Unpin, even though Sleep does not.

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use tokio::time::Sleep;

struct HasSleep {
    sleep: Pin<Box<Sleep>>,
}

impl Future for HasSleep {
    type Output = ();

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        self.sleep.as_mut().poll(cx)
    }
}

Use in a struct with pin projection. This method avoids the Box, but the HasSleep struct will not be Unpin as a consequence.

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use tokio::time::Sleep;
use pin_project_lite::pin_project;

pin_project! {
    struct HasSleep {
        #[pin]
        sleep: Sleep,
    }
}

impl Future for HasSleep {
    type Output = ();

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        self.project().sleep.poll(cx)
    }
}