Struct Timer 

pub struct Timer { /* private fields */ }

A high-precision future that completes after a specified duration.

Timer provides platform-native timing capabilities that leverage operating system scheduling primitives for accurate delays without busy-waiting. The timer integrates seamlessly with async/await and provides zero-cost abstraction over native OS APIs.

Platform Behavior

• Apple platforms: Uses GCD’s dispatch_after for precise scheduling
• Other platforms: Will use platform-specific high-resolution APIs

Performance

Unlike thread-based sleep implementations, Timer doesn’t block threads and allows the executor to handle other tasks while waiting.

Examples

use native_executor::timer::Timer;
use std::time::Duration;

async fn precise_timing() {
    // Millisecond precision timing
    Timer::after(Duration::from_millis(250)).await;
     
    // Second-based convenience method
    Timer::after_secs(2).await;
}

Implementations

impl Timer

pub fn after(duration: Duration) -> Self

Creates a new Timer that will complete after the specified duration.

Arguments

• duration - The amount of time to wait before the timer completes.

Returns

A new Timer instance that can be awaited.

Example

use native_executor::timer::Timer;
use std::time::Duration;

async fn example() {
    // Wait for 1 second
    Timer::after(Duration::from_secs(1)).await;
    println!("One second has passed!");
}

Examples found in repository

examples/timers.rs (line 13)

fn main() {
    spawn(async {
        println!("Starting timers example");

        // Use the Timer API
        println!("Waiting for 500ms...");
        Timer::after(Duration::from_millis(500)).await;
        println!("500ms elapsed");

        // Use the seconds convenience method
        println!("Waiting for 1 second...");
        Timer::after_secs(1).await;
        println!("1 second elapsed");

        // Use the sleep convenience function
        println!("Sleeping for 2 seconds...");
        sleep(2).await;
        println!("2 seconds elapsed");

        println!("Timers example completed");
    })
    .detach();

    // Keep the main thread alive
    std::thread::sleep(Duration::from_secs(4));
}

pub fn after_secs(secs: u64) -> Self

Creates a new Timer that will complete after the specified number of seconds.

This is a convenience method that wraps Timer::after with Duration::from_secs.

Arguments

• secs - The number of seconds to wait before the timer completes.

Returns

A new Timer instance that can be awaited.

Example

use native_executor::timer::Timer;

async fn example() {
    // Wait for 5 seconds
    Timer::after_secs(5).await;
    println!("Five seconds have passed!");
}

Examples found in repository

examples/simple_task.rs (line 12)

fn main() {
    println!("Starting example");

    // Spawn a task with default priority
    spawn(async {
        println!("Task started");

        // Wait for 1 second
        Timer::after_secs(1).await;

        println!("Task completed after 1 second");
    })
    .detach();

    // Keep the main thread alive
    std::thread::sleep(Duration::from_secs(2));

    println!("Example completed");
}

examples/priority.rs (line 8)

fn main() {
    // Spawn a default priority task
    spawn(async {
        println!("Default priority task started");
        Timer::after_secs(1).await;
        println!("Default priority task completed");
    })
    .detach();

    // Spawn a background priority task
    spawn_with_priority(
        async {
            println!("Background priority task started");
            Timer::after_secs(1).await;
            println!("Background priority task completed");
        },
        Priority::Background,
    )
    .detach();

    // Keep the main thread alive
    std::thread::sleep(Duration::from_secs(2));
}

examples/timers.rs (line 18)

fn main() {
    spawn(async {
        println!("Starting timers example");

        // Use the Timer API
        println!("Waiting for 500ms...");
        Timer::after(Duration::from_millis(500)).await;
        println!("500ms elapsed");

        // Use the seconds convenience method
        println!("Waiting for 1 second...");
        Timer::after_secs(1).await;
        println!("1 second elapsed");

        // Use the sleep convenience function
        println!("Sleeping for 2 seconds...");
        sleep(2).await;
        println!("2 seconds elapsed");

        println!("Timers example completed");
    })
    .detach();

    // Keep the main thread alive
    std::thread::sleep(Duration::from_secs(4));
}

Trait Implementations

impl Debug for Timer

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

Formats the value using the given formatter.

impl Future for Timer

type Output = ()

The type of value produced on completion.

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

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