异步编程与 Tokio：让等待的时间干活

async fn fetch_cover(id: u32) -> String {
    println!("开始拉取封面 {id}");
    tokio::time::sleep(std::time::Duration::from_millis(100)).await; // 模拟网络耗时
    println!("封面 {id} 到手");
    format!("cover-{id}.png")
}

[dependencies]
tokio = { version = "1", features = ["full"] }   # 学习期直接开 full，生产按需精简

#[tokio::main]                  // 语法糖：建多线程运行时 + block_on
async fn main() {
    let cover = fetch_cover(1).await;
    println!("{cover}");
}

fn main() {
    let rt = tokio::runtime::Runtime::new().unwrap(); // worker 线程数默认按 CPU 核数
    rt.block_on(async {
        let cover = fetch_cover(1).await;
        println!("{cover}");
    });
}

#[tokio::main]
async fn main() {
    let a = fetch_cover(1).await;   // 等 100ms
    let b = fetch_cover(2).await;   // 再等 100ms
    // 总耗时 200ms——两个任务并没有并发！
}

use tokio::join;

#[tokio::main]
async fn main() {
    let (a, b) = join!(fetch_cover(1), fetch_cover(2));
    // 两个任务并发推进，总耗时约 100ms（取最慢者），结果按序返回
    println!("{a} {b}");
}

#[tokio::main]
async fn main() {
    let tasks: Vec<_> = (0..1000)
        .map(|id| tokio::spawn(fetch_cover(id)))   // 1000 个任务并发跑在少量线程上
        .collect();

    let mut covers = vec![];
    for t in tasks {
        covers.push(t.await.unwrap());   // JoinHandle 的结果是 Result（任务可能 panic）
    }
    println!("拉取完成 {} 张", covers.len());   // 总耗时约等于最慢一批的时间
}

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

match timeout(Duration::from_secs(2), fetch_cover(7)).await {
    Ok(cover) => println!("拿到 {cover}"),
    Err(_) => eprintln!("封面 7 超时，走兜底"),
}

use tokio::select;

select! {
    cover = fetch_cover(1) => println!("数据先到：{cover}"),
    _ = tokio::time::sleep(Duration::from_secs(1)) => println!("1 秒到了，放弃等待"),
}

use std::sync::Arc;
use tokio::sync::Mutex;

#[tokio::main]
async fn main() {
    let counter = Arc::new(Mutex::new(0u32));

    let mut handles = vec![];
    for _ in 0..10 {
        let c = Arc::clone(&counter);
        handles.push(tokio::spawn(async move {
            let mut n = c.lock().await;   // 注意：锁本身要 .await
            *n += 1;
        }));
    }
    for h in handles { h.await.unwrap(); }
    println!("成功 {}", *counter.lock().await);
}

// 错误：同步 sleep 卡住 worker 线程，跑在该线程上的所有任务全部停摆
std::thread::sleep(Duration::from_secs(1));

// 正确：异步 sleep，让出线程
tokio::time::sleep(Duration::from_secs(1)).await;

let heavy = tokio::task::spawn_blocking(|| {
    // 同步的、CPU 密集的计算，跑在独立线程池，不占异步 worker
    (0..10_000_000u64).sum::<u64>()
});
println!("{}", heavy.await.unwrap());

use std::sync::Mutex;   // 错误示范的根源

async fn bad(m: &Mutex<u32>) {
    let _guard = m.lock().unwrap();
    fetch_cover(1).await;   // 若能编译：guard 跨 await 持有，同一线程上的其他任务
}                           // 想拿同一把锁时，而当前任务又挂起不放 —— 死锁

// 编译错误: recursive async fn
// async fn rec(n: u32) -> u32 {
//     if n == 0 { 0 } else { rec(n - 1).await + 1 }
// }

// 正确：Box::pin 把 Future 固定到堆上，大小变成确定的指针
async fn rec(n: u32) -> u32 {
    if n == 0 { 0 } else { Box::pin(rec(n - 1)).await + 1 }
}

use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::Mutex;
use tokio::time::timeout;

async fn fetch_cover(id: u32) -> String {
    tokio::time::sleep(Duration::from_millis(100)).await;  // 模拟网络
    format!("cover-{id}.png")
}

#[tokio::main]
async fn main() {
    let stats = Arc::new(Mutex::new((0u32, 0u32)));  // (成功, 超时)
    let start = Instant::now();

    let tasks: Vec<_> = (0..1000)
        .map(|id| {
            let stats = Arc::clone(&stats);
            tokio::spawn(async move {
                match timeout(Duration::from_millis(500), fetch_cover(id)).await {
                    Ok(cover) => {
                        let mut s = stats.lock().await;
                        s.0 += 1;
                        Some(cover)
                    }
                    Err(_) => {
                        let mut s = stats.lock().await;
                        s.1 += 1;
                        None
                    }
                }
            })
        })
        .collect();

    let mut covers = vec![];
    for t in tasks {
        if let Some(c) = t.await.unwrap() { covers.push(c); }
    }

    let (ok, timed_out) = *stats.lock().await;
    println!("成功 {ok} 张，超时 {timed_out} 张，耗时 {:?}", start.elapsed());
    // 1000 个任务并发推进，总耗时约几百毫秒，而非串行的 100 秒
}