pub struct Sleep { /* private fields */ }
Expand description
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
sourceimpl Sleep
impl Sleep
sourcepub fn is_elapsed(&self) -> bool
pub fn is_elapsed(&self) -> bool
Returns true
if Sleep
has elapsed.
A Sleep
instance is elapsed when the requested duration has elapsed.
sourcepub fn reset(self: Pin<&mut Self>, deadline: Instant)
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));
See also the top-level examples.
Trait Implementations
impl<'__pin> Unpin for Sleep where
__Origin<'__pin>: Unpin,
Auto Trait Implementations
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<F> IntoFuture for F where
F: Future,
impl<F> IntoFuture for F where
F: Future,
type Output = <F as Future>::Output
type Output = <F as Future>::Output
into_future
)The output that the future will produce on completion.
type IntoFuture = F
type IntoFuture = F
into_future
)Which kind of future are we turning this into?
sourcefn into_future(self) -> <F as IntoFuture>::IntoFuture
fn into_future(self) -> <F as IntoFuture>::IntoFuture
into_future
)Creates a future from a value.