Struct `Sleep`

struct Sleep { ... }

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]
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]
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)
    }
}

Implementations

`impl Sleep`

fn deadline(self: &Self) -> Instant

Returns the instant at which the future will complete.

fn is_elapsed(self: &Self) -> bool

Returns true if Sleep has elapsed.

A Sleep instance is elapsed when the requested duration has elapsed.

fn reset(self: Pin<&mut Self>, deadline: Instant)

Resets the Sleep instance to a new deadline.

Calling this function allows changing the instant at which the Sleep future completes without having to create new associated state.

This function can be called both before and after the future has completed.

To call this method, you will usually combine the call with Pin::as_mut, which lets you call the method without consuming the Sleep itself.

Example

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

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

sleep.as_mut().reset(Instant::now() + Duration::from_millis(20));
# }

`impl Debug for Sleep`

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

`impl Freeze for Sleep`

`impl Future for Sleep`

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<<Self as >::Output>

`impl RefUnwindSafe for Sleep`

`impl Send for Sleep`

`impl Sync for Sleep`

`impl UnsafeUnpin for Sleep`

`impl UnwindSafe for Sleep`

`impl<F> IntoFuture for Sleep`

fn into_future(self: Self) -> <F as IntoFuture>::IntoFuture

`impl<T> Any for Sleep`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Sleep`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Sleep`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for Sleep`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for Sleep`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Sleep`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Sleep`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>