Function sleep 

pub async fn sleep(duration: Duration)

Sleep for a specified duration

Examples found in repository

examples/timeout_demo.rs (line 5)

async fn slow_operation() -> i32 {
    sleep(Duration::from_secs(5)).await;
    42
}

async fn fast_operation() -> i32 {
    sleep(Duration::from_millis(100)).await;
    100
}

examples/hello_world.rs (line 10)

fn main() {
    let rt = Runtime::new();

    rt.block_on(async {
        println!("Hello from avx Async!");

        sleep(Duration::from_secs(1)).await;

        println!("One second later...");
    });
}

examples/industry40_autoscale.rs (line 75)

fn spawn_tasks(rt: &Runtime, count: usize, delay: Duration) {
    for i in 0..count {
        rt.spawn(async move {
            avx_async::sleep(delay).await;
            // Simulate CPU work
            let mut sum = 0u64;
            for j in 0..1000 {
                sum = sum.wrapping_add(j);
            }
        });
    }
}

async fn monitor_for_seconds(rt: &Runtime, seconds: u64) {
    let end_time = std::time::Instant::now() + Duration::from_secs(seconds);

    while std::time::Instant::now() < end_time {
        avx_async::sleep(Duration::from_millis(500)).await;

        let snapshot = rt.metrics().snapshot();
        let active_tasks = snapshot.tasks_spawned - snapshot.tasks_completed;

        println!(
            "  [{}s] Tasks: {} active, {} queued | Threads: {} active, {} idle | TPS: {}",
            (seconds - (end_time - std::time::Instant::now()).as_secs()),
            active_tasks,
            snapshot.queue_length,
            snapshot.active_threads,
            snapshot.idle_threads,
            snapshot.tasks_per_second
        );
    }
}

examples/industry40_tracing.rs (line 10)

async fn process_order(ctx: &TraceContext, order_id: u64) {
    let mut span = ctx.child_span("process_order");
    span.set_attribute("order_id", order_id.to_string());
    span.add_event("order_received");

    // Simulate order validation
    avx_async::sleep(Duration::from_millis(50)).await;
    span.add_event("order_validated");

    // Simulate payment processing
    avx_async::sleep(Duration::from_millis(100)).await;
    span.add_event("payment_processed");

    // Simulate fulfillment
    avx_async::sleep(Duration::from_millis(75)).await;
    span.add_event("order_fulfilled");

    println!("✅ Order {} processed", order_id);

    let completed_span = span.end();
    println!("   {}", completed_span);
}

examples/parallel_tasks.rs (line 14)

fn main() {
    let rt = Runtime::new();

    rt.block_on(async move {
        println!("Spawning 100 concurrent tasks...");

        let mut handles = vec![];

        for i in 0..100 {
            let handle = rt.spawn_with_handle(async move {
                avx_async::sleep(Duration::from_millis(10)).await;
                i * i
            });
            handles.push(handle);
        }

        println!("Waiting for all tasks to complete...");

        let mut sum = 0;
        for handle in handles {
            if let Some(result) = handle.await_result().await {
                sum += result;
            }
        }

        println!("Sum of squares from 0 to 99: {}", sum);
        println!("Active tasks: {}", rt.task_count());
    });
}

examples/channel_demo.rs (line 18)

fn main() {
    let rt = Runtime::new();

    rt.block_on(async move {
        let (tx, rx) = channel::bounded::<String>(10);

        // Spawn producer task
        rt.spawn({
            let tx = tx.clone();
            async move {
                for i in 0..5 {
                    let msg = format!("Message {}", i);
                    println!("Sending: {}", msg);
                    tx.send(msg).await.unwrap();
                    avx_async::sleep(Duration::from_millis(500)).await;
                }
            }
        });

        // Spawn another producer
        rt.spawn({
            async move {
                for i in 0..5 {
                    let msg = format!("Urgent {}", i);
                    println!("Sending: {}", msg);
                    tx.send(msg).await.unwrap();
                    avx_async::sleep(Duration::from_millis(300)).await;
                }
            }
        });

        // Receive messages
        let mut count = 0;
        while let Some(msg) = rx.recv().await {
            println!("Received: {}", msg);
            count += 1;
            if count >= 10 {
                break;
            }
        }

        println!("All messages received!");
    });
}

Additional examples can be found in:

• examples/industry40_metrics.rs
• examples/industry40_health.rs