Rust Async

You are a Rust async programming expert. The user wants to implement async programming with Tokio runtime, including spawning tasks, handling multiple concurrent operations, and managing async/await patterns.

What to check first

• Verify Tokio is in Cargo.toml: cargo tree | grep tokio
• Check Rust version supports async/await (1.39+): rustc --version
• Confirm you have the tokio feature flags needed: full or specific features like rt-multi-thread, macros, io-util

Steps

1. Add tokio with required features to Cargo.toml: tokio = { version = "1.0", features = ["full"] }
2. Use #[tokio::main] macro on your main function to initialize the runtime automatically
3. Mark functions as async fn that need to perform non-blocking I/O or await other futures
4. Use .await to wait for futures to complete without blocking the thread
5. Spawn independent tasks with tokio::spawn() to run futures concurrently on the runtime
6. Use tokio::select! macro to wait for multiple futures and handle the first one to complete
7. Handle errors with Result types and the ? operator in async contexts
8. Join spawned tasks with JoinHandle::await or use tokio::join! for multiple tasks

Code

use std::time::Duration;
use tokio::time::sleep;
use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    println!("Starting async runtime");
    
    // Example 1: Simple async function
    fetch_data().await;
    
    // Example 2: Spawn multiple concurrent tasks
    let task1 = tokio::spawn(async {
        sleep(Duration::from_secs(1)).await;
        "Task 1 done"
    });
    
    let task2 = tokio::spawn(async {
        sleep(Duration::from_millis(500)).await;
        "Task 2 done"
    });
    
    // Wait for both tasks
    let result1 = task1.await.expect("Task 1 panicked");
    let result2 = task2.await.expect("Task 2 panicked");
    println!("{}, {}", result1, result2);
    
    // Example 3: Channel communication between tasks
    let (tx, mut rx) = mpsc::channel(10);
    
    tokio::spawn(async move {
        for i in 0..3 {
            tx.send(i).await.ok();
            sleep(Duration::from_millis(100)).await;
        }
    });
    
    while let Some(value) = rx.recv().await {
        println!("Received: {}", value);
    }
    
    // Example 4: Select between multiple futures

Note: this example was truncated in the source. See the GitHub repo for the latest full version.

Common Pitfalls

• Treating this skill as a one-shot solution — most workflows need iteration and verification
• Skipping the verification steps — you don't know it worked until you measure
• Applying this skill without understanding the underlying problem — read the related docs first

When NOT to Use This Skill

• When a simpler manual approach would take less than 10 minutes
• On critical production systems without testing in staging first
• When you don't have permission or authorization to make these changes

How to Verify It Worked

• Run the verification steps documented above
• Compare the output against your expected baseline
• Check logs for any warnings or errors — silent failures are the worst kind

Production Considerations

• Test in staging before deploying to production
• Have a rollback plan — every change should be reversible
• Monitor the affected systems for at least 24 hours after the change