异步编程基础:future、任务与运行时Copy Anchor Link

这一章讲什么: Rust 的异步模型——第三版新增的一章。主线是一个小网络爬虫: 并发抓两个网页,谁快用谁。全程借它讲清三件事:future 是什么(惰性、要等 await)、 运行时是什么(语言不带,要用 block_on 启动)、并发怎么发生(只发生在 await 点)。 读完你能写 async 函数、知道为什么 main 不能是 async、知道为什么长任务里要 yield。

1. 顶层全景:先分清三个词Copy Anchor Link

并发(concurrency)vs 并行(parallelism):一个人两个任务来回切换是并发;两个人各干各的是并行;单核 CPU 上只有并发,多核才可能并行——async 通常实现并发,底下是否并行取决于运行时¹。

为什么需要 async:网络等 I/O 函数是阻塞的——不调完不走。给每个下载开一个线程也行,但线程的资源开销会累积。async 的答案是:不阻塞调用,而是声明一堆任务,让运行时决定执行顺序²。

  线程模型:代码现在就要跑(spawn 立即执行)      → 并发由操作系统调度
  async 模型:代码声明"将来会就绪"(惰性)        → 并发由运行时调度,await 点是切换口

  图说:spawn 是"立刻开干",async fn 是"先登记,await 时才动工"。

2. Future 与 async/await 语法Copy Anchor Link

future 是"现在没好、将来会好"的值;Rust 里实现 Future trait 的类型就是 future。 async fn 在函数上加 async,体内用 await 等另一个 future;每个 await 都是这个函数可能暂停、之后恢复的点;检查 future 好了没有叫 poll³。

主线例子的核心函数:

async fn page_title(url: &str) -> Option<String> {
    let response_text = trpl::get(url).await.text().await;   // 两次网络等待
    Html::parse(&response_text).select_first("title")
        .map(|title| title.inner_html())
}

两个必须记住的机制:① future 是惰性的——不 await 什么都不发生(像迭代器不 next 就不动;不信会收到编译警告)。② async fn 是语法糖:它返回的是一个实现了 Future<Output = 原返回类型> 的匿名类型,函数体被包进一个 async 块⁴。await 是后缀关键字(写在表达式后面),所以能链式 .await.text().await。

为什么 main 不能是 async(E0752):async 代码需要运行时——一个管理异步代码执行细节的 crate;main 可以初始化运行时,但它本身不是运行时,总得有个非 async 的起点。多数语言把运行时捆在语言里,Rust 不捆——web 服务器和单片机要的运行时完全不同,生态里(tokio 等)各取所需。手工启动的姿势:trpl::block_on(async { ... })——阻塞当前线程直到这个 future 跑完⁵。

await 点的本质:编译器把 async 块编译成一个状态机(每个 await 点一个状态变体,保存跨点所需的数据);运行时的 executor 负责驱动这个状态机——这就是"暂停/恢复"的实现方式,也是"await 只能出现在 async 里"的原因⁶。

3. 并发地等:select、join 与任务Copy Anchor Link

• race 两个 future:trpl::select(fut1, fut2).await 返回 Either::Left/Right,谁先完成用谁——爬虫"两个网址谁快用谁"就是这么做的。
• spawn_task ≈ async 版的 thread::spawn,返回的句柄本身是 future,handle.await 等它跑完(对应线程的 join)。
• trpl::join(fut1, fut2):不建任务,把两个匿名 future 并发跑到都完成;它是"公平"的——轮流检查两边。join! 宏等任意多个编译期已知数量的 future。
• async 通道:async 版 mpsc,rx.recv().await 不阻塞而是把控制权交还运行时;接收循环用 while let Some(v) = rx.recv().await(Rust 还没有 async 版 for)⁷。

两个 async 新手必撞的坑(书里都演了一遍):① 单个 async 块里的代码顺序执行——消息要并发收发,得把发送和接收拆进两个 async 块再 join;② 发送端不 drop,接收端的 recv 永不返回 None,程序永不退出——解法是发送块用 async move(把 tx 移进去,块结束即 drop)⁸。

4. 协程纪律:await 点之间没有并发Copy Anchor Link

Rust 只在 await 点把控制权还给运行时;两个 await 点之间是纯同步代码。 于是在 async 块里跑长计算会饿死其他 future。解法序列:在慢操作之间插 trpl::sleep(1ms).await(勉强) → 换 trpl::yield_now().await(只交还控制、不睡,意图明确且更快)⁹。这是协作式多任务:每个 future 自己决定何时让路,也有责任不让路太久。但 yield 不是免费的——把计算密集任务切碎可能反而更慢;"先测量再优化"的老话在这里同样适用。

5. 底层三件套:poll、Pin、StreamCopy Anchor Link

本章最后掀开盖子,三个进阶件只需知道"是什么、为什么":

Future trait 的真身:

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

poll 问一次"好了吗":Ready(值) 或 Pending(并借由 Context/Waker 约定"就绪后叫我")。运行时就是反复 poll 的循环¹⁰。

为什么 poll 要 Pin<&mut Self>:async 块编译出的状态机会自引用(某个状态变体里存着指向同一块数据里另一字段的引用)。带自引用的值一旦移动,内部引用就指向旧地址——悬垂。Pin 是一个"钉住不许动"的指针包装,编译器用它保证自引用类型不被移动;所以想把 future 装进 Vec 一起 join 时,要用 pin! 宏钉住再移容器。书给的使用建议很直白:Pin/Unpin 主要给写底层库和运行时的人,日常代码在报错信息里见到能认出来就行¹¹。

Stream = 随时间就绪的序列:poll_next(...) -> Poll<Option<Item>>——外层 Poll 学 Future(可能还没好),内层 Option 学 Iterator(可能有多个)。标准库当时还没有 Stream,生态用 futures crate 的定义;StreamExt::next() 让它可以 .await 着用¹²。

6. 作者的判断与证据Copy Anchor Link

• "future 惰性对 Rust 的性能承诺是必要的"——设计论证,与迭代器的惰性类比⁴。
• "Rust 不捆绑运行时,多种运行时服务不同场景"——生态系统设计主张⁵。
• "await 点之间是同步的;长任务要主动 yield"——机制事实,配了饥饿实验⁹。
• "Pin 主要给底层库"——使用建议,降低读者焦虑¹¹。

判断(我们的,不是书里的): 本章最反直觉也最重要的一条是 "await 点之间没有并发"—— 它把 async 从"免费的并行"还原成"显式的让路协议":并发不是 async 白送的, 是你每次写 await 时买一次的。这解释了为什么 async Rust 的典型 bug (忘记 await、忘记 yield、发送端不 drop)全是"协议没遵守",而不是语法错误。 如果错,会错在: 某些运行时的调度器可能自动抢占长任务(协作式不是唯一实现), 但语言层的保证确实只有 await 点——书以 trpl/tokio 的常规语义为准,没覆盖特殊调度器。

7. 边界与局限Copy Anchor Link

• 运行时的实现(executor、reactor、Waker 细节)明确超出本章;指了 async book。
• unsafe、手写 Future、async trait(当时还不是稳定特性)都只给了轮廓。
• 性能比较(async vs 线程)给了定性讨论,无数值基准。

8. 可带走的Copy Anchor Link

1. 并发 ≠ 并行:单核可并发,多核才并行;async 通常实现并发。
2. future = 现在没好将来会好的值;async fn 返回一个 Future。
3. future 惰性:不 await 不执行;编译器会警告未用的 future。
4. main 不能是 async:async 需要运行时;用 block_on 启动。
5. await 是后缀关键字;await 点 = 暂停/恢复点;状态机由编译器生成。
6. select 竞速、join/join! 等全部、spawn_task + handle.await 等单个。
7. 单 async 块内顺序执行;收发要拆两块 join;发送端要 move 进去才能干净退出。
8. await 点之间无并发;长任务插 yield_now().await。
9. poll 返回 Ready/Pending;Pin 钉住自引用状态机;Stream = Poll + Option。
10. Pin/Unpin 日常只需"报错时认得"。

9. 原文地图Copy Anchor Link