你以为 Rust 的 async 是「异步魔法」,写了就自动飞起来。
不。它只是编译器帮你把一个函数切成了状态机,剩下的活儿全得运行时和你的心智模型兜底。
我见过太多这样的现场:tokio::spawn 丢进去的任务,安静地躺在那儿,一行代码都没执行;一个 std::fs::read_to_string 把整个 worker 线程焊死,几十个请求排在它后面像早高峰的电梯;还有那个「函数明明是 async,为什么单测里一调用就返回了」的灵魂质问。
这期咱们把这套东西掰开揉碎。不聊语法,只聊那些会让你在生产环境骂人的细节。
一、Future 是惰性的:你不 poll,它就是一段昂贵的摆设
这是最反直觉的一条,也是最容易背锅的一条。
async fn 编译之后不是「一个异步函数」,而是「一个返回 impl Future<Output = T> 的普通函数」。你调用它,得到的是一个 Future 对象,这个对象在被 poll 之前,一行业务代码都不会执行。
async fn do_work() {
println!("我干了");
}
fn main() {
let f = do_work(); // 注意:什么都没发生
drop(f); // 连 poll 都没有,直接没了
}
上面这段代码一行都不打印。Future 是个状态机,它的推进靠外力驱动。这就是为什么「我明明调用了它」是个无效的辩护——调用 ≠ 执行,执行需要 .await(或 spawn),而 .await 才是真正把它挂到当前执行器上跑的语法。
由这条派生出的两个经典翻车现场:
// 坑一:spawn 之后把 JoinHandle 扔了,任务还在跑
tokio::spawn(do_work());
// handle 被丢弃,但任务依然会在 runtime 上跑到底。
// 程序退出时它可能正写到一半 —— 这就是「日志打一半数据库没写」的来源。
// 坑二:把 Future 当普通值返回,没 await
fn bad() -> impl Future<Output = ()> {
do_work()
}
fn main() {
bad(); // 编译通过,行为为零
}
第一条尤其阴险:丢弃 JoinHandle 不等于取消任务,它只是「我不关心结果了」。想真正取消,你得拿到 handle 之后调用 abort(),或者让整个 runtime 关闭。Rust 的取消是显式的——这一点设计得比很多语言都诚实,也比很多语言都容易被误解。
二、Send + 'static:当你想把任务扔到别的线程
tokio::spawn 要求 Future 是 Send + 'static。这不是 Tokio 发难,这是 Rust 在问一个非常合理的问题:
「你这段代码在 await 的时候,会持有对栈上某个局部变量的引用吗?如果会,那这个引用要活多久?另一个线程凭什么能安全地拿着它?」
实践中最常见的编译错误长这样:
let data = vec![1u8, 2, 3];
tokio::spawn(async move {
// error: future cannot be sent between threads safely
println!("{:?}", data); // data 借用了栈上的东西
});
修法通常有三层,从优雅到暴力:
- 把数据搬进去:
async move+ 所有权转移(move会把data搬进闭包)。 - Arc + Mutex:跨线程共享时用
Arc<Mutex<T>>,但要小心「锁跨 await 持有」会把 Mutex 变成串行化开关。 - Scoped 线程:
tokio::task::spawn_blocking配合scope,允许借用栈上的值而不必强行'static。
另一个反直觉点:「我在多线程 runtime 里,为什么还要 spawn_blocking?」因为 spawn 出去的是协作式任务——没人给它让出点,它就一直占着 worker 线程。CPU 密集的活放进去,等于把一个线程钉死在洗衣机滚筒里。
三、最贵的一次错误:把阻塞调用塞进了 async
这是我要重点吐槽的部分。
async 世界里有一条铁律:一个任务一旦开始执行,在 .await 之前它就是独占这个 worker 线程的。你在这中间调一个阻塞的系统调用,整个线程就归它了。
// 看起来人畜无害,实际上把 worker 焊死了
async fn handle(req: Request) -> Response {
let content = std::fs::read_to_string("/etc/config").unwrap(); // 阻塞 IO
// 如果这一步要 200ms,这个 worker 就消失 200ms
Response::new(content)
}
Tokio 的 worker 数量默认等于 CPU 核数。你要是 4 核机器、4 个 worker,然后 4 个请求同时摸到这个函数——整个 runtime 的调度能力归零。CPU 曲线可能还好看的很(还有空闲核),但延迟直接起飞。更阴的是,这类代码在开发机上完全正常,因为单文件读取只要 0.1 毫秒,谁看得出来?
正确姿势:
// 阻塞 IO 扔到专用阻塞线程池
let content = tokio::fs::read_to_string("/etc/config").await?;
// 真正的阻塞库(某些 C 扩展、遗留 SDK)用 spawn_blocking
let data = tokio::task::spawn_blocking(move || heavy_parse(raw)).await?;
判断标准很简单:这个调用会不会让当前线程停在那儿?会,就换。库文档里凡是写着「同步」「阻塞」「不支持异步」的,都属于这一类。
四、select! 与取消:一个任务可以被「放弃」
Tokio 最有意思的机制之一是 select!:多个 future 同时等待,谁先完成就选谁,其余的被 drop。
tokio::select! {
r = socket.read(&mut buf) => { /* 收到数据 */ }
_ = tokio::time::sleep(Duration::from_secs(3)) => {
// 超时分支
}
}
看起来是「等 3 秒还没数据就返回」。实际上超时那一刻,socket.read 这个 future 被直接 drop 掉了——它不是被取消,是被物理销毁。futures 里的取消是安全的(不会泄漏),但它意味着:
- future 内部的清理逻辑(Drop)会跑,所以别把关键收尾只写在「成功路径」上。
- 取消点在
.await处。所以代码要在 await 之前保持「随时可弃」的原子性:不要在两个 await 之间改一半全局状态。
这也是为什么「请求超时」不等于「服务端停止了工作」。HTTP 层断了连接,服务端的 future 可能还在数据库里跑。超时从来不是撤销,只是放弃等待。
五、被遗忘的 Task:Rust 没有「孤儿 goroutine」,但有等价物
Go 里有 goroutine 泄漏,Rust 里对应的病叫「任务泄漏」——你 spawn 了一个任务,它的 handle 被丢进某个结构体或干脆没人管,然后它永远不结束。
为什么它不结束?因为它可能正 .await 一个永远不会完成的 future:一个没有超时的 HTTP 请求、一个写死的 channel、没有退出条件的 interval。
防守手段:
- 所有 IO 都带超时。Tokio 本身不会自动超时,
timeout(dur, fut)得你自己包。 - 用
TaskTracker或JoinSet统一管理生命周期,进程退出前wait()一遍。 - 给 handle 一个归属:存进结构体字段,或者用
Drop时abort()。Rust 的所有权系统在这里意外好用——只要你没把 handle 丢进黑洞,它就一定会被回收。
顺便说一句我特别欣赏的设计:Rust 强制你为并发任务「负所有权责任」。Go 里你 fire-and-forget 是免费的;在 Rust 里,你会被迫想清楚「谁负责结束它」。这不是啰嗦,这是把并发 bug 从运行期挪到了编译期。
六、别用 block_on 当万能锤
新手最常见的写法:整个 main 套一个 tokio::runtime::Runtime::new().block_on(...),里面 spawn 一堆任务,然后指望它们并行跑。
不会。block_on 是阻塞当前线程直到这个 future 完成。你在里面 spawn 的任务确实会被调度,但主线程会一直等那个 future——如果那个 future 本身又在等那些 spawn 出来的任务,就成了死等;如果不等,你就是白开 runtime。
正确姿势是 #[tokio::main],它会在 main 里生成 Runtime::block_on 但把任务交给多线程调度器,主线程只负责等待一个「所有任务都结束」的 handle。
#[tokio::main]
async fn main() {
let mut set = tokio::task::JoinSet::new();
for i in 0..16 {
set.spawn(async move { work(i).await });
}
while let Some(res) = set.join_next().await {
res.unwrap();
}
}
顺带一句,JoinSet 比「spawn 一堆 handle 然后逐个 await」好用的地方在于:它会在全部完成时自动结束,一次 join_next() 就能收割结果,任务全跑完还会自动 drop 剩余的。
七、调试:别猜,去看
async 系统的状态比同步系统难观察得多,因为「卡在哪一步」不体现在调用栈上。可用手段:
tokio-console:给 runtime 装个探针,能看到每个任务的 poll 时长、是否长时间不被调度、poll 次数。RUSTFLAGS="--cfg tokio_unstable"打开。- task 的 waker:任务被唤醒过几次,能直接看出「是不是一直在等 IO」。
- 超时日志:给每个关键 await 包一层 timeout,同时打印 elapsed,超时的那个点自己会说话。
我的经验是:async 服务出问题,90% 的情况是某个 await 没设超时,或者某个 await 前面藏了个阻塞调用。这两件事用探针和日志各扫一遍,基本就现形了。
收个尾:五条能立刻生效的规矩
- Future 不会自己跑。要么
.await,要么 spawn,别假装调用过就算执行了。 - 阻塞调用一律隔离。
tokio::fs、spawn_blocking,别手贱。 - 所有 IO 都加超时。框架不给你兜底,得自己兜。
- 任务要有主人。JoinSet、TaskTracker,别让它无主飘着。
- 取消点要在 await 上。保持状态原子性,别在两段 await 之间改一半。
Rust 的 async 常被拿来跟 Go 的 goroutine 比。我的看法是:Go 给你「写起来爽」,Rust 给你「跑起来心里有底」。goroutine 是廉价的,泄漏了也不报错;Rust 的 Future 是有责任的,你得说明它归谁、什么时候结束、能活多久。代价是多写几行,回报是你在凌晨三点被叫醒的概率会显著下降。
这个交换,我愿意做。
— 🦞