Rust异步编程实战:理解async/await与tokio核心机制
1. 别急着写代码,先理解 async/await 到底在解决什么问题
很多刚接触 Rust 的朋友,看到 async fn 和 .await 就下意识地用写 JavaScript 或 Python 的思路去套,结果跑出各种莫名其妙的问题。第 13 课我想先从最根上把这件事掰开揉碎讲清楚——Rust 的 async/await 不是“语法糖”,它是一套基于轮询(poll)的协作式调度模型。你只有理解了 Future 是惰性的、await 是挂起点、执行器才是真正驱动力,后面用 tokio 时才知道自己在干什么。
1.1 一个最简单的异步函数,背后发生了什么
先看一段再普通不过的代码:
这里的关键不是 await 本身,而是 async fn 的返回值。你调用 fetch_page() 时,函数体一行都不会执行,它只是构造了一个 Future 对象。你可以把它理解成一张“外卖订单”,下单之后厨房还没开始做菜,订单本身只是一张纸。只有当你把这张订单交给执行器(executor),让执行器去 poll 这个 Future,函数体才会真正跑起来。
poll 这个词很多人觉得抽象,其实可以这样想:执行器隔一段时间问 future:“你准备好了吗?准备好了就把结果给我,没准备好我就去处理别的任务。” 当 fetch_page 内部执行到 download_page().await 时,实际上是在对 download 返回的 future 执行一次 poll。如果下载还没完成,这个 future 会返回 Pending,意思是“我还没好,你可以去干别的了”。于是 fetch_page 这个 future 本身也返回 Pending,状态被保存在一个 Pin<Box<dyn Future>> 或者其他容器里。等到下载完成,执行器再次 poll 它,它会从上次挂起的地方继续执行。
这就是 Rust 异步的核心:编译期状态机 + 运行时轮询。编译器会把一个 async 函数拆成若干个状态,每次 await 就是一个可能挂起的边界点。这比回调函数清晰得多,也比线程切换轻量得多。
1.2 Future 的惰性、Pin 和运行时执行器
既然 Future 是惰性的,那就必须回答一个问题:谁来驱动它?Rust 标准库只提供了 Future trait 和 async/await 语法,但标准库没有执行器。这跟 Go 不一样,Go 的 goroutine 是语言运行时内置的;Rust 选择了把执行器放到第三方库,比如 tokio、async-std、smol。也就是说,你可以在没有操作系统线程概念的嵌入式环境里实现一个极简执行器,也可以在一个多核服务器上跑 tokio 的多线程运行时。
另一个绕不开的概念是 Pin。为什么要 Pin?因为一个 async 函数的内部可能会生成自引用结构——比如你在局部变量里存了一个指向另一个局部变量堆上的指针,而 future 在状态机切换时可能会被移动。如果让编译器默认允许移动,这个内部指针就悬空了。Pin 的作用就是约束 future 在内存中的位置,让它不要被随意搬走。这也是新手最容易遇到的编译错误之一:future is not Send 或 cannot be unpinned。你只要记住:在异步代码里传递 future、跨线程 spawn 任务时,要先考虑它是否满足 Send 和 'static。
那么执行器具体怎么驱动?简单理解就是一个事件循环:它维护一个任务队列和一个 reactor(I/O 事件源),不断从队列里取出任务,调用 poll;如果任务返回 Pending,就把它挂到对应的 I/O 等待列表里,等事件到达再唤醒。tokio 之所以快,很大程度上归功于它对这套机制的精细优化,而不是“线程多”这么简单。
1.3 线程为什么不能直接解决问题
说到异步,总会有人问:“我开 10 个线程不一样吗?” 区别在于线程切换是操作系统内核完成的,每次切换要保存/恢复寄存器、刷新缓存,成本是微秒级;而异步任务切换只是内存里的一个函数调用,成本是纳秒级。更关键的是,线程的数量受系统资源限制,一个 8 核机器开个几千线程能把内存吃光;而 async 任务可以开几十万,因为每个任务只占很小的栈空间(或者根本不需要独立栈)。在 I/O 密集场景(网络请求、数据库读写、文件操作)下,你把任务切成异步,让线程空出来跑别的计算,吞吐量能有数量级提升。
但异步也不是银弹。如果任务是 CPU 密集型的、需要长时间占用核心做计算,异步反而没优势,甚至因为额外调度开销变得更慢。所以正确姿势是:I/O 密集用 async,CPU 密集用线程或 spawn_blocking。
2. tokio:你真正要接触的异步运行时
tokio 是目前 Rust 生态里事实标准的异步运行时,Hyper、axum、tonic 这些主流库都基于它。学 async 不学 tokio,就像有了驾照不开车上路。但 tokio 提供的东西非常多,一开始不要想着把所有 API 都背下来,先把三个核心组件弄懂:runtime(运行时)、task(任务)、reactor(事件驱动)。这三个点通了,其他都是 API 熟悉度的问题。
2.1 runtime 的两种形态与选择
tokio 的 runtime 有两种主流形态:多线程运行时(multi-thread)和当前线程运行时(current_thread)。你也许已经见过 #[tokio::main] 这个宏,默认就是多线程运行时,它会在你写主函数的地方创建一个 runtime,然后 block_on 进去执行。
| 形态 | 使用方式 | 适用场景 | 注意事项 |
|---|---|---|---|
| 多线程运行时 | #[tokio::main] |
Web 服务、混有 CPU/阻塞/IO 的复杂系统 | 默认线程数等于 CPU 核数,任务会在线程间“偷”着跑 |
| 当前线程运行时 | #[tokio::main(flavor = "current_thread")] |
轻量同步脚本、嵌入式、测试 | 所有任务挤在一个线程上,代码里不要有阻塞操作 |
选哪种?如果你只是在写一个小工具、做本地文件处理、或者测试时想让行为更可预测,current_thread 够用。若你跑的是一个 HTTP 服务、要并发处理大量网络请求,多线程运行时才是正解。多线程运行时的内部结构是一个全局任务队列加每个工作线程自己的本地队列,采用“工作窃取”机制:某个线程本地队列空了,会从别人那里偷任务过来执行,这样能最大化利用所有核心。
我经常看到有人这样写:
直接把这个 CPU 计算放到 async 主函数里跑,没问题,但它会长时间占住某个工作线程,导致其他排在这个线程上的任务延迟被调度。严格来说,对于 CPU 密集任务,你应该用 tokio::task::spawn_blocking 给它放到独立的阻塞线程池,或者用 rayon 并行计算。阻塞线程池的大小也可以配置,默认是 512 个线程,你可以 Builder::new_threaded_runtime().max_blocking_threads(n) 去调。
2.2 spawn、异步任务与 Send 约束
tokio::spawn 大概是除了 await 之外你用得最多的函数。它可以在当前 runtime 里创建一个新的异步任务,返回一个 JoinHandle。举个例子:
注意 spawn 要求 future 满足 Send + 'static。Send 是因为多线程运行时的任务可能被扔到任意线程执行;'static 是因为这个 future 需要存活到任务结束,不能借用外部非静态生命周期数据。如果你不小心在 async 块里用了 &str 引用外部的字符串,编译器会马上报错。这时候有两种常见解法:一是把数据 clone 进任务内,二是改用 Arc 共享。'static 约束看起来很烦,其实它是一个保险——多线程异步任务本质上就是给你发出去一个“寄件”,你总不能寄一个写着“请打开这个信封但信封握在别人手里”的包裹吧。
关于 JoinHandle,还有一点容易被忽略:handle.await 返回的是一个 Result<T, JoinError>。如果任务 panic 了,你在这里会收到 Err,而且 panic 不会导致整个程序崩溃。所以如果你不关心子任务的结果,可以直接 handle.abort() 或者让它跑完;但如果你想保证任务内的错误不静默丢失,尽量在任务内部用 Result 返回值,而不是在任务里 panic。
2.3 tokio 的 features 怎么开
新手最容易踩的坑之一:use tokio::time::sleep 报错找不到。因为 tokio 默认只开启少量 feature,其它功能需要显式启用。你在 Cargo.toml 里写:
full 把所有常用特性全打开了,开发期可以偷懒。如果是发布产品,尽量按需精减:
features 之间有关联,比如 rt-multi-thread 依赖 rt,macros 提供 #[tokio::main]。你如果只写 async/await 语法,不一定要引入 tokio 的 macro,可以用 Runtime::new().unwrap().block_on(async { ... })。我在教学时常跟大家说:先从逻辑学起,再关心 features;一旦功能缺了,CV 错误信息就能定位到缺少哪个 feature——因为 tokio 的编译错误写得相当直白。
3. 实操:用 tokio 写一个带限流的并发抓取器
前面的原理讲得再多,不写代码等于零。这节我们做一个小而完整的项目:用 reqwest + tokio 并发抓取一批 URL 的标题,同时限制最大并发数为 5,每个请求超时 10 秒,失败自动重试一次。这个场景几乎适用于任何“批量调接口/爬网页”的工作,也可以推广到并发数据库查询或外部 API 调用。
3.1 先搭一个最小可运行的异步程序
新建一个项目:
Cargo.toml 先加上依赖:
这里没有用 full,是因为我们只想跑通流程。reqwest 默认用系统 TLS,在 Linux 上如果你没装 openssl 的 dev 包会编译失败,所以教学推荐直接用 rustls-tls,纯 Rust 实现,少踩很多系统依赖的坑。
先写一个超简单的异步入口:
注意这里 tokio::time::sleep(...).await 不是真的让线程睡 1 秒,而是让当前任务挂起,当前线程可以去执行其他任务。执行器会在定时器到期后重新唤醒它。你可以用同样的代码开 100 个 sleep 任务,理论上总耗时仍然接近 1 秒,而不是串行执行的 100 秒。
3.2 引入并发度限制:Semaphore 的正确用法
不加限制地 join_all 并发请求,很容易把目标服务器打挂,也容易把自己机器的文件描述符耗尽。tokio 提供了 Semaphore(信号量),它的思路很直观:一个计数器代表还有多少个“许可”(permit),每次任务开始前要先“购买”一个许可,结束后归还。
这里有个细节:let _permit = sem.acquire().await 得到的 SemaphorePermit 会在作用域结束(也就是这个 async 块跑到 fetch_url(...).await 完成之后)自动 drop,从而释放许可。如果你不小心把它写成了 let permit 并在整个任务中持有,也能正常限制并发,但要注意permit 必须保存在任务内,而不是在外部提前 acquire。我们是在任务内部 acquire,所以同一时刻最多 5 个任务处于“已获得许可且正在请求”的状态,其余任务会先挂起,等许可释放后再继续。
3.3 加上超时与重试,让程序更耐操
单纯的 send().await 可能遇到对方迟迟不响应,默认 reqwest 的超时时间很长,甚至可能无限等下去。你需要用 tokio::time::timeout 包一层:
但 timeout 和 Future 的取消有个陷阱:如果 future 内部没有在 await 点检查取消状态,那么 timeout 返回 Err 后,future 可能仍然在后台继续执行。比如一个 sleep 10 秒的任务,你在 1 秒时 timeout,它其实还在 runtime 的任务队列里睡完剩下 9 秒。这通常没问题,但如果那个任务持有某个锁、或者占用了连接池连接,就可能造成资源泄漏或锁的意外延长持有。解法是尽量让 I/O 操作本身具备响应取消的能力——tokio 的网络和 sleep 操作都会在 drop 时取消注册,因此并发代码里用 select! 或 timeout 取消一个 tcp_stream.read(...).await 是安全的。
重试逻辑也很简单,但要注意“指数退避”别太激进:
一般来说,对于 5xx 类错误可以重试,对于 4xx 类客户端错误不要重试,否则可能会把你的账号封掉。更完善的做法是读取 resp.status() 判断状态码是否可重试,这留给读者自己扩展。
3.4 用一个简单的 TCP 服务串联等待机制(可选扩展)
限流抓取只是 async 的一个侧面。如果你在做 Web 服务,tokio 背后真正的功臣是 TcpListener + TcpStream 的异步 I/O 驱动。这里贴一段简单的 echo server,帮你体会 accept().await 的循环:
每来一个连接,accept().await 返回,然后 spawn 一个异步任务处理它。这个模型跟 sync 的 std::net 线程池模型最大的区别是:你不需要给每个连接分配一个线程,无论 100 还是 10 万个连接,占用的线程资源基本固定。当然,真实生产环境不会这样裸写 TCP,你会用 axum、actix-web 或者 hyper。但底层逻辑都差不多:监听端口 -> 异步读取请求 -> 异步写回响应 -> 关闭连接。
4. 踩坑记录:async 代码里的隐形杀手
讲完实操,再来聊一聊我在给团队做 Rust 异步代码 review 时反复看到的几类问题。每一个都是真实项目里炸过的雷,写下来给后来人当参考。
4.1 在异步代码中用了阻塞函数和标准库锁
最常见的问题就是在 async 函数里写了 std::thread::sleep 或者 std::sync::Mutex。前者会直接阻塞当前线程,而多线程 runtime 的工作线程被阻塞时,它执行队列里的其他任务全都被卡住。虽然 tokio 加入了新的阻塞任务检测机制,能提示哪些任务阻塞了 runtime,但最好自己养成好习惯:任何阻塞操作都丢进 tokio::task::spawn_blocking:
std::sync::Mutex 的问题更隐蔽。你在 .await 之前用它保护共享数据,编译器不报错,但一旦这个锁被某个线程持有着并跨越 .await,另一个线程可能也会尝试获取同一个锁,于是死锁或者导致未来阻塞。正确的做法是使用 tokio 的异步锁:tokio::sync::Mutex。它的 lock().await 是异步的,不会阻塞线程。不过异步锁也有额外的等待成本,如果你只是保护一小段不跨越 await 的操作,用标准库锁或者直接改写为局部变量更高效。
4.2 跨 .await 持有非 Send 引用
如果你在 async 块里使用 Rc、RefCell 或者其他非 Send 类型,编译时会收到 future cannot be sent between threads safely 的错误。因为多线程 runtime 可能在 await 边界处把 future 迁移到另一个线程。有人觉得烦,就试图用 current_thread runtime 绕过。如果业务逻辑确实完全单线程,那可行;但如果你的目标是服务端并发,正确姿势是把非 Send 类型改成 Arc + Mutex 或 Arc + RwLock,或者只在这段代码里让它短暂存在,不跨越 await。
还有一个相对少见的坑:async 块内部借用局部数组的切片,编译器也可能推断出一个不满足 'static 的生命周期。解决办法通常是 Box::pin 之前先 collect 或者把数据 move 进任务。遇到这种错误,别硬调代码,先看错误信息里提示的 'static 是从哪个变量引入的,再做数据归属调整。
4.3 运行时初始化失败或嵌套 block_on
有人会写自己的线程池,然后在里面逐个创建 tokio runtime:
这在某些场景下是合理的,但要注意每个 runtime 都有自己的事件循环线程池,如果你创建几十个 runtime,就等于创建了几百个线程,物理内存和调度负担都很大。更合理的是创建一个全局 runtime,然后用 Runtime::block_on 在需要的入口使用,或者在其他线程里通过 Handle::try_current 拿到句柄再 spawn 进去。
还有个非常经典的错误:在一个 tokio 异步任务内部再调用 Runtime::block_on。因为你已经处于异步上下文,block_on 会阻塞当前线程,还会去处理 runtime 里的其他任务,容易造成死锁。如果确实需要一个新 runtime 来隔离任务,至少要建立独立的 runtime 并小心地跨线程传递;但一般不需要,直接用 spawn 就行。
4.4 依赖拉取慢、镜像源配置速查
Rust 开发中另一个让新手当场崩溃的问题是 cargo build 拉取 crates.io 很慢,尤其在国内网络环境下,tokio 这样的大型依赖可能要拉好几分钟。解决办法是配置 crates.io 镜像源。在你本机的 ~/.cargo/config.toml(Windows 是 C:\Users\你的用户名\.cargo\config.toml)里写入:
这种 sparse+ 协议是较新的索引方式,比旧的 git 索引快很多。另外还可以配置 [net] git-fetch-with-cli = true(可选)来复用你系统里已有的 git 客户端。不同镜像的域名和地址会变化,建议大家自己去官方文档查最新配置,别轻信博客里写死的老地址。配置完成之后,重新 cargo build,速度提升极明显。
4.5 一张速查表:从症状到解法
| 症状 | 可能原因 | 快速解法 |
|---|---|---|
| 程序卡住不退出,CPU 0% | async 任务一直在 Pending,执行器以为还有活要干 | 检查是否所有 tokio 线程都退出了;用 select! 加超时 |
reqwest 请求一直不返回 |
没有设置超时 | 用 tokio::time::timeout 包裹 |
| 多线程 runtime 下日志乱序 | 任务被多个线程执行 | 不要依赖打印顺序,用 tracing 带 span 追踪 |
编译错误 future is not Send |
异步块内使用了 Rc/RefCell |
换成 Arc/异步锁/局部变量 |
编译错误 missing feature |
tokio 没打开相应 feature | 按报错补 feature,或直接用 full |
运行时 panic:There is no reactor running |
没有 tokio runtime 就在调 tokio::time/net | 进入 #[tokio::main] 或 block_on 后再用 |
cargo build 极慢 |
crates.io 源慢 | 配置国内镜像源 |
写异步代码这么多年,我的核心体会是:先顺着“共享数据 -> 任务边界 -> 阻塞点”这个链条把模型想清楚,再落笔写 spawn。不要一上来就把每个函数都变成 async。有些函数里面全是 CPU 计算,写成 async 只会增加无谓的调度开销;有些函数虽然内部没有网络 I/O,但会被上层 await 后才能拿到结果,这时候保持 async 反而让调用链更统一。
另外,调试 tokio 程序时,一定要学会 tokio-console 这个工具。它可以直观看到当前 runtime 里所有任务的调度状态、等待位置和阻塞时长,比打印日志高效得多。版本更新很快,装法直接看它的 GitHub README 就行。如果手头没有图形界面,也可以先用 RUST_LOG=trace 打开 tracing 日志观察关键事件。
如果你正准备开始写自己的第一个 async 项目,我建议从一个小工具练手,而不是一上来就造 Web 框架。先把 spawn、select!、Semaphore、mpsc channel 这四个组件用熟,再把它们组合起来解决一个实际问题,比如批处理脚本、消息转发中间件、定时任务调度器。你对异步的掌控感会很快建立起来。