Struct actix_web::rt::time::Sleep

pub struct Sleep { /* private fields */ }

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

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 Sleep>, 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));

See also the top-level examples.

Trait Implementations

impl Debug for Sleep

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

Formats the value using the given formatter.

impl Future for Sleep

type Output = ()

The type of value produced on completion.

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

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

impl<'__pin> Unpin for Sleepwhere
    __Origin<'__pin>: Unpin,