async/await patterns: spawning tasks and joining futures

Developers run async tasks sequentially with .await when they should run concurrently, or misuse spawn and lose track of task handles.

Use tokio::join! for concurrent futures and tokio::spawn for independent tasks:

use tokio::time::{sleep, Duration};

async fn task_a() -> &'static str { sleep(Duration::from_millis(100)).await; "A" }
async fn task_b() -> &'static str { sleep(Duration::from_millis(100)).await; "B" }

// Sequential — takes 200ms
async fn sequential() {
    let a = task_a().await;
    let b = task_b().await;
    println!("{} {}", a, b);
}

// Concurrent — takes ~100ms
async fn concurrent() {
    let (a, b) = tokio::join!(task_a(), task_b());
    println!("{} {}", a, b);
}

// Spawned task runs independently
async fn spawned() {
    let handle = tokio::spawn(async {
        sleep(Duration::from_millis(50)).await;
        42u32
    });
    // Do other work here...
    let result = handle.await.unwrap(); // JoinError if task panicked
    println!("Result: {}", result);
}

Futures in Rust are lazy — awaiting them one by one is sequential. tokio::join! polls multiple futures on the same task concurrently. tokio::spawn creates a new task that can run on a different thread.