pub struct Interval { /* private fields */ }
Expand description
Interval returned by interval
and interval_at
.
This type allows you to wait on a sequence of instants with a certain
duration between each instant. Unlike calling sleep
in a loop, this lets
you count the time spent between the calls to sleep
as well.
An Interval
can be turned into a Stream
with IntervalStream
.
Implementations§
source§impl Interval
impl Interval
sourcepub async fn tick(&mut self) -> Instant
pub async fn tick(&mut self) -> Instant
Completes when the next instant in the interval has been reached.
§Cancel safety
This method is cancellation safe. If tick
is used as the branch in a tokio::select!
and
another branch completes first, then no tick has been consumed.
§Examples
use tokio::time;
use std::time::Duration;
#[tokio::main]
async fn main() {
let mut interval = time::interval(Duration::from_millis(10));
interval.tick().await;
// approximately 0ms have elapsed. The first tick completes immediately.
interval.tick().await;
interval.tick().await;
// approximately 20ms have elapsed.
}
sourcepub fn poll_tick(&mut self, cx: &mut Context<'_>) -> Poll<Instant>
pub fn poll_tick(&mut self, cx: &mut Context<'_>) -> Poll<Instant>
Polls for the next instant in the interval to be reached.
This method can return the following values:
Poll::Pending
if the next instant has not yet been reached.Poll::Ready(instant)
if the next instant has been reached.
When this method returns Poll::Pending
, the current task is scheduled
to receive a wakeup when the instant has elapsed. Note that on multiple
calls to poll_tick
, only the Waker
from the
Context
passed to the most recent call is scheduled to receive a
wakeup.
sourcepub fn reset(&mut self)
pub fn reset(&mut self)
Resets the interval to complete one period after the current time.
This method ignores MissedTickBehavior
strategy.
This is equivalent to calling reset_at(Instant::now() + period)
.
§Examples
use tokio::time;
use std::time::Duration;
#[tokio::main]
async fn main() {
let mut interval = time::interval(Duration::from_millis(100));
interval.tick().await;
time::sleep(Duration::from_millis(50)).await;
interval.reset();
interval.tick().await;
interval.tick().await;
// approximately 250ms have elapsed.
}
sourcepub fn reset_immediately(&mut self)
pub fn reset_immediately(&mut self)
Resets the interval immediately.
This method ignores MissedTickBehavior
strategy.
This is equivalent to calling reset_at(Instant::now())
.
§Examples
use tokio::time;
use std::time::Duration;
#[tokio::main]
async fn main() {
let mut interval = time::interval(Duration::from_millis(100));
interval.tick().await;
time::sleep(Duration::from_millis(50)).await;
interval.reset_immediately();
interval.tick().await;
interval.tick().await;
// approximately 150ms have elapsed.
}
sourcepub fn reset_after(&mut self, after: Duration)
pub fn reset_after(&mut self, after: Duration)
Resets the interval after the specified std::time::Duration
.
This method ignores MissedTickBehavior
strategy.
This is equivalent to calling reset_at(Instant::now() + after)
.
§Examples
use tokio::time;
use std::time::Duration;
#[tokio::main]
async fn main() {
let mut interval = time::interval(Duration::from_millis(100));
interval.tick().await;
time::sleep(Duration::from_millis(50)).await;
let after = Duration::from_millis(20);
interval.reset_after(after);
interval.tick().await;
interval.tick().await;
// approximately 170ms have elapsed.
}
sourcepub fn reset_at(&mut self, deadline: Instant)
pub fn reset_at(&mut self, deadline: Instant)
Resets the interval to a crate::time::Instant
deadline.
Sets the next tick to expire at the given instant. If the instant is in
the past, then the MissedTickBehavior
strategy will be used to
catch up. If the instant is in the future, then the next tick will
complete at the given instant, even if that means that it will sleep for
longer than the duration of this Interval
. If the Interval
had
any missed ticks before calling this method, then those are discarded.
§Examples
use tokio::time::{self, Instant};
use std::time::Duration;
#[tokio::main]
async fn main() {
let mut interval = time::interval(Duration::from_millis(100));
interval.tick().await;
time::sleep(Duration::from_millis(50)).await;
let deadline = Instant::now() + Duration::from_millis(30);
interval.reset_at(deadline);
interval.tick().await;
interval.tick().await;
// approximately 180ms have elapsed.
}
sourcepub fn missed_tick_behavior(&self) -> MissedTickBehavior
pub fn missed_tick_behavior(&self) -> MissedTickBehavior
Returns the MissedTickBehavior
strategy currently being used.
sourcepub fn set_missed_tick_behavior(&mut self, behavior: MissedTickBehavior)
pub fn set_missed_tick_behavior(&mut self, behavior: MissedTickBehavior)
Sets the MissedTickBehavior
strategy that should be used.