第23课：Tokio运行时

🎯 本课目标

掌握Tokio异步运行时的核心概念：任务、调度器、IO驱动和定时器。

1. Tokio基础

// Cargo.toml
[dependencies]
tokio = { version = "1", features = ["full"] }

// 最简Tokio程序
#[tokio::main]
async fn main() {
    println!("Hello from Tokio!");
}

// 等价于
fn main() {
    tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()
        .unwrap()
        .block_on(async {
            println!("Hello from Tokio!");
        })
}

✅ 编译验证通过

2. 任务与spawn

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

#[tokio::main]
async fn main() {
    // spawn创建并发任务
    let handle = tokio::spawn(async {
        sleep(Duration::from_millis(100)).await;
        "任务完成"
    });

    // 等待任务
    let result = handle.await.unwrap();
    println!("结果: {}", result);

    // 多任务并发
    let mut handles = vec![];
    for i in 0..5 {
        handles.push(tokio::spawn(async move {
            sleep(Duration::from_millis(50 * i as u64)).await;
            i * i
        }));
    }

    for h in handles {
        println!("结果: {}", h.await.unwrap());
    }
}

✅ 编译验证通过

3. 运行时配置

// 多线程运行时（默认）
#[tokio::main]
async fn main() { }

// 单线程运行时（轻量级）
#[tokio::main(flavor = "current_thread")]
async fn main() { }

// 自定义工作线程数
#[tokio::main(worker_threads = 4)]
async fn main() { }

// 手动构建
let rt = tokio::runtime::Builder::new_multi_thread()
    .worker_threads(4)
    .thread_stack_size(2 * 1024 * 1024)
    .enable_all()
    .build()
    .unwrap();

4. Tokio组件

5. 异步同步原语

use tokio::sync::{Mutex, Semaphore, broadcast, mpsc};

#[tokio::main]
async fn main() {
    // 异步Mutex（跨.await持有）
    let data = Mutex::new(0);
    {
        let mut lock = data.lock().await;
        *lock += 1;
    }

    // 信号量（限制并发数）
    let sem = Semaphore::new(3);  // 最多3个并发
    let permit = sem.acquire().await.unwrap();

    // 广播通道
    let (tx, mut rx1) = broadcast::channel(16);
    let mut rx2 = tx.subscribe();

    // mpsc通道
    let (tx, mut rx) = mpsc::channel(32);
}

📝 练习题

🔬 深度理解：异步编程模型

📊 异步模型对比

🌐 网络编程最佳实践

📚 扩展阅读

🔑 关键术语回顾

💬 学习建议

🤔 常见问题