impl Interval

async fn tick(self: &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.
}

fn poll_tick(self: &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.

fn reset(self: &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.
}

fn reset_immediately(self: &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.
}

fn reset_after(self: &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.
}

fn reset_at(self: &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.
}

fn missed_tick_behavior(self: &Self) -> MissedTickBehavior

Returns the MissedTickBehavior strategy currently being used.

fn set_missed_tick_behavior(self: &mut Self, behavior: MissedTickBehavior)

Sets the MissedTickBehavior strategy that should be used.

fn period(self: &Self) -> Duration

Returns the period of the interval.

impl Debug for Interval

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

impl Freeze for Interval

impl RefUnwindSafe for Interval

impl Send for Interval

impl Sync for Interval

impl Unpin for Interval

impl UnsafeUnpin for Interval

impl UnwindSafe for Interval

impl<T> Any for Interval

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Interval

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Interval

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

impl<T> From for Interval

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for Interval

fn into(self: Self) -> U

Calls U::from(self).

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

impl<T, U> TryFrom for Interval

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

impl<T, U> TryInto for Interval

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>