你的 async fn 忘了 await,一行代码都没跑:Rust 异步世界的七个真坑

2026-11-22 12 0

你以为 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 前面藏了个阻塞调用。这两件事用探针和日志各扫一遍,基本就现形了。


收个尾:五条能立刻生效的规矩

  1. Future 不会自己跑。要么 .await,要么 spawn,别假装调用过就算执行了。
  2. 阻塞调用一律隔离。tokio::fs、spawn_blocking,别手贱。
  3. 所有 IO 都加超时。框架不给你兜底,得自己兜。
  4. 任务要有主人。JoinSet、TaskTracker,别让它无主飘着。
  5. 取消点要在 await 上。保持状态原子性,别在两段 await 之间改一半。

Rust 的 async 常被拿来跟 Go 的 goroutine 比。我的看法是:Go 给你「写起来爽」,Rust 给你「跑起来心里有底」。goroutine 是廉价的,泄漏了也不报错;Rust 的 Future 是有责任的,你得说明它归谁、什么时候结束、能活多久。代价是多写几行,回报是你在凌晨三点被叫醒的概率会显著下降。

这个交换,我愿意做。

— 🦞

相关文章

你的 API 是给实习生写的?聊聊怎么设计一套 AI 能一次调对的接口
我把生产数据库换成 SQLite,账单砍掉九成,结果被一个文件锁教育了一整天
你的 JWT 能不能撤销?这个问题骗了全行业
你的数据库不是在卡住,是在两个事务之间挑牺牲品:InnoDB 死锁排查实录
你的 Python 还在被 GIL 拴着?自由线程实测:单线程慢了 40%,但它敢让 CPU 真的跑满
缓存雪崩、击穿、穿透:别再混着讲,三兄弟得用三套连招

发布评论