异步与网络

第22课：async/await

🎯 本课目标

理解Rust异步编程模型、Future trait、async/await语法和执行器概念。

1. 异步编程基础

Rust的异步模型是零成本抽象——编译器将async函数转换为状态机，无需隐藏的堆分配或运行时。

use std::future::Future;

// async fn 返回 impl Future
async fn fetch_data(id: u32) -> String {
    // 模拟异步操作
    std::thread::sleep(std::time::Duration::from_millis(100));
    format!("数据{}", id)
}

// 等价写法
fn fetch_data_explicit(id: u32) -> impl Future<Output = String> {
    async move {
        format!("数据{}", id)
    }
}

async fn process() {
    // .await 等待Future完成（不阻塞线程）
    let data = fetch_data(1).await;
    println!("获取: {}", data);

    // 顺序执行
    let a = fetch_data(1).await;
    let b = fetch_data(2).await;

    // 并发执行
    let (a, b) = join(fetch_data(1), fetch_data(2)).await;
}

// join需要futures crate
use futures::join;

✅ 编译验证通过

2. Future trait

pub trait Future {
    type Output;
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

pub enum Poll<T> {
    Ready(T),      // 完成
    Pending,        // 未完成，Waker已注册
}

Future执行模型： 1. 执行器调用 poll() 2. 如果Ready → 返回值 3. 如果Pending → 注册Waker 4. 当IO就绪，Waker被唤醒 5. 执行器再次poll() ┌──────┐ poll ┌──────────┐ │执行器 │────────→│ Future │ │ │←────────│ │ │ │ Pending │ 注册Waker│ └──────┘ └──────────┘ ↑ │ │ wake! │ IO就绪 └──────────────────┘ 关键：.await是语法糖，编译器生成状态机每个.await点是一个状态转换

3. async块与生命周期

async fn example() {
    let data = String::from("hello");

    // async块捕获引用
    let fut = async {
        println!("{}", data);  // 借用data
    };

    // 需要move来获取所有权
    let fut2 = async move {
        println!("{}", data);  // 所有权移入
    };

    fut.await;
}

// 'static Future
fn get_future() -> impl Future<Output = i32> {
    async move { 42 }  // 无捕获 = 'static
}

✅ 编译验证通过

4. Select与并发模式

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

async fn task_a() -> &str { "A完成" }
async fn task_b() -> &str { "B完成" }

async fn race() {
    // select! — 第一个完成的胜出
    select! {
        result = task_a() => println!("{}", result),
        result = task_b() => println!("{}", result),
    }

    // 带超时
    select! {
        result = task_a() => println!("结果: {}", result),
        _ = sleep(Duration::from_secs(5)) => println!("超时"),
    }
}

5. 异步与同步对比

特性	同步	异步
阻塞	整个线程	仅当前任务
并发数	受限于线程数	可达数十万
开销	线程栈1-8MB	任务状态几百字节
适用	CPU密集	IO密集

📝 练习题

练习1：并发下载

用join!并发执行多个异步任务。

练习2：超时包装

用select!为任意Future添加超时。

练习3：自定义Future

手动实现Future trait。

🏆

成就解锁：时间旅行者

掌握async/await——非阻塞世界的钥匙

⬅ 上一课 🏠 目录下一课 ➡

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

Rust的异步模型与其他语言有本质区别：

1. 编译器生成状态机

async函数不是语法糖生成闭包或Future对象，而是编译器生成一个状态机enum，每个.await点是一个状态。这比Green Thread更高效——无堆分配、无运行时开销。

2. 零成本异步

不使用的异步特性不产生代码。不调用async函数？没有状态机代码。这与其他语言的全局运行时（Go的goroutine调度器、Java的Fiber）不同。

3. 显式运行时

Rust没有内置异步运行时。你选择Tokio、async-std或其他——运行时是库，不是语言特性。这意味着灵活但需要选择。

📊 异步模型对比

模型	语言	开销	并发数
OS线程	C/Java	1-8MB/线程	~1000
Green Thread	Go	~2KB/goroutine	~100K
async/await	Rust	~几百字节	~1M+
回调	Node.js	小	高

🌐 网络编程最佳实践

背压控制：使用tokio::sync::Semaphore限制并发
超时设置：所有IO操作加超时，避免挂起
优雅关闭：监听信号，等待进行中的请求完成
连接池：复用TCP连接，减少握手开销
零拷贝：使用bytes::Bytes避免不必要的数据复制
结构化日志：使用tracing替代println

📚 扩展阅读

以下资源帮助你深入学习本课主题：

The Rust Programming Language — 官方教程，Rust圣经
Rust by Example — 通过示例学习Rust
Rust Reference — 语言参考手册
Rustnomicon — Unsafe Rust黑魔法指南
Too Many Lists — 用Rust实现各种链表

🔑 关键术语回顾

本课涉及的核心概念，确保你理解每一个：

术语	说明
所有权	Rust内存管理的核心机制，每个值有唯一所有者
借用	通过引用访问数据，不获取所有权
生命周期	引用有效的范围，编译期分析工具
trait	Rust的接口/抽象机制，类似其他语言的接口
泛型	参数化类型，零成本抽象
模式匹配	强大的数据解构和分支机制
零成本抽象	高层抽象不引入运行时开销
fearless concurrency	编译器保证线程安全

💬 学习建议

动手编码 — 每个代码示例都在本地运行一遍
修改实验 — 故意改错代码，看编译器报什么错
完成练习 — 每课的练习题是巩固知识的关键
阅读源码 — 看标准库和优秀开源项目的实现
写项目 — 真正掌握需要构建真实项目

🤔 常见问题

Q: Rust学习曲线真的很陡吗？

A: 前期确实需要适应所有权和借用检查器，但一旦理解了，这些概念会让你的代码更可靠。大多数人2-4周就能上手。

Q: Rust适合什么项目？

A: 系统编程、Web服务、CLI工具、嵌入式、WASM、网络服务、数据库等。基本上需要性能和安全的地方都适合。

Q: 遇到编译错误怎么办？

A: Rust编译器的错误信息非常友好！仔细阅读，通常会指出问题所在和修复建议。也可以用cargo clippy获取更多提示。