Struct Sleep

pub struct Sleep { /* private fields */ }

Available on crate feature time only.

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

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

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

pub fn deadline(&self) -> Instant

Returns the instant at which the future will complete.

pub fn is_elapsed(&self) -> bool

Returns true if Sleep has elapsed.

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

pub 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};

let sleep = tokio::time::sleep(Duration::from_millis(10));
tokio::pin!(sleep);

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

Trait Implementations

impl Debug for Sleep

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

Formats the value using the given formatter. Read more

impl Future for Sleep

type Output = ()

The type of value produced on completion.

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

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more

Auto Trait Implementations

impl !Freeze for Sleep

impl !RefUnwindSafe for Sleep

impl !UnsafeUnpin for Sleep

impl !UnwindSafe for Sleep

impl Send for Sleep

impl Sync for Sleep

Blanket Implementations

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

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

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

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

impl<F> IntoFuture for F
where F: Future,

type Output = <F as Future>::Output

The output that the future will produce on completion.

type IntoFuture = F

Which kind of future are we turning this into?

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

Creates a future from a value. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more