# tokio::time::Sleep - Rust
API documentation for the Rust `Sleep` struct in crate `tokio`.
Keywords: rust, rustlang, rust-lang, Sleep

# Struct tokio::time::Sleep [−] [src]

    #[must_use = "futures do nothing unless you `.await` or poll them"]pub struct Sleep { /* fields omitted */ }

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` [src]

#### `pub fn deadline(&self) -> Instant` [src]

Returns the instant at which the future will complete.

#### `pub fn is_elapsed(&self) -> bool` [src]

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)` [src]

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` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl Future for Sleep` [src]

#### `type Output = ()`

The type of value produced on completion.

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

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

### `impl<'__pin> Unpin for Sleep where
__Origin<'__pin>: Unpin,` [src]

## Auto Trait Implementations

### `impl !RefUnwindSafe for Sleep` [src]

### `impl Send for Sleep` [src]

### `impl Sync for Sleep` [src]

### `impl !UnwindSafe for Sleep` [src]

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<F> IntoFuture for F where
F: Future,` [src]

#### `type Output = <F as Future>::Output`

🔬 This is a nightly-only experimental API. (`into_future`)

The output that the future will produce on completion.

#### `type Future = F`

🔬 This is a nightly-only experimental API. (`into_future`)

Which kind of future are we turning this into?

#### `pub fn into_future(self) -> <F as IntoFuture>::Future` [src]

🔬 This is a nightly-only experimental API. (`into_future`)

Creates a future from a value.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.