一个用 tokio 写的服务,压测时单请求只要几毫秒,上线后 P99 变成两秒。查日志没发现慢 SQL,CPU 也不高,最后定位到某个 handler 里调了一个同步的图像处理库,处理一张大图要几百毫秒。代码写得很自然:async fn handle() 里直接调用,看起来是异步的,实际上那个调用把整个 worker 线程占住了,同一线程上排队的其他任务全部往后挪。

这就是 async 最常见的误解:以为加了 async 就自动并发。真实情况是,异步运行时用少量线程驱动大量任务,任何一个任务在 poll 里阻塞,都会让那个线程上的其他任务一起等。这一篇用 tokio 1.54 在本机实际跑几组对照:任务完成顺序、abort 取消、timeout、阻塞调用与 spawn_blocking 的差别。所有数字都是这台机器上的实测,只说明量级,不是性能结论。

runtime 是什么,#[tokio::main] 展开了什么

tokio 的 runtime 负责三件事:调度任务、驱动定时器、注册 IO 就绪事件。它有两种常见形态。new_multi_thread 会开一组 worker 线程,任务在多个线程之间调度,适合服务端;new_current_thread 只有一个线程,任务都在这个线程上跑,适合测试、轻量工具,也适合「我想自己控制线程模型」的场景。

#[tokio::main] 不是魔法,它把 async fn main 包了一层:创建一个 runtime,然后 block_on 那个 future。默认是多线程 runtime,worker 数量默认等于 CPU 核数(可以用 worker_threads 调整)。所以「加了宏就能跑」的本质,是「有人替你建了执行器并开始 poll」。

选哪种形态可以显式写出来:#[tokio::main(flavor = "current_thread")] 只用一个线程,适合命令行工具和测试;#[tokio::main(worker_threads = 4)] 指定 worker 数量,适合容器里 CPU 配额被限制的场景。默认值不一定适合你:容器里 available_parallelism 可能读到宿主机的核数,开出远超配额的线程,反而增加调度开销。部署前确认 worker 数与资源限制匹配,不要假设「核数越多越好」。

一个容易撞上的错误是「在 runtime 里再建 runtime」。实测在 #[tokio::main] 的异步上下文里调用 Builder::new_current_thread().build(),程序直接 panic,报错原文:

Cannot start a runtime from within a runtime. This happens because a function
(like `block_on`) attempted to block the current thread while the thread is
being used to drive asynchronous tasks.

这不是 tokio 小气,而是嵌套执行器会让外层线程被内层 block_on 占死。block_on 是同步入口,只能出现在最外层。要在异步代码里跑一段独立的任务,用 tokio::spawn;要跑阻塞代码,用 spawn_blocking,不要新建 runtime。

spawn 与 JoinHandle:任务是任务,不是线程

tokio::spawn 把一个 future 交给 runtime,立刻返回 JoinHandle,future 在后台被调度。它要求 future 是 'static + Send:'static 是因为任务可能比当前函数活得久,不能借用栈上的东西;Send 是因为它可能被挪到别的 worker 线程。满足这两个条件的常见做法是 move 闭包加 Arc 共享状态。

实测三个任务分别睡 120、60、10 毫秒,然后 join! 等全部完成:

task-3    => 10ms 任务完成, 10.0386ms
task-2    => 60ms 任务完成, 60.0548ms
task-1    => 120ms 任务完成, 120.0623ms
joined    => 1 2 3

完成顺序按耗时,而不是按 spawn 顺序,说明它们确实在并发等待。但「并发」不等于「各占一个线程」:三个任务可能都由同一个 worker 驱动,只是每次都在 await 处让出,等待区间重叠。任务的开销远小于线程,可以创建几十万个短任务;但任务不是免费的,每个任务都有状态机和调度开销,不能用「反正是异步」来掩盖设计问题。

JoinHandle 被 drop 不会取消任务,任务会继续在后台跑,这叫「detach」。这既是特性( fire-and-forget 的日志、心跳),也是泄漏来源:请求处理里 spawn 了任务却没人管,出错时看不到,任务越积越多。要么保存句柄并等待,要么用 JoinSet 统一管理,要么明确接受「它会自己结束」。

JoinSet 适合「动态数量的一组任务」:join_set.spawn(...) 之后,用 while let Some(res) = join_set.join_next().await 逐个收结果。它会在集合被 drop 时中止所有未完成的任务,这一点比散落的 JoinHandle 安全得多。限制是它要求任务返回同一类型,或者至少能放进同一个 Result 里;任务结果类型差异很大时,就各管各的句柄。

JoinHandle 等待失败时返回 JoinError,它分两种:任务 panic 了,或者任务被取消。err.is_panic() 和 err.is_cancelled() 要分开处理:前者说明代码有 bug,要记日志、可能触发告警;后者是正常停机流程的一部分,不该当成故障。把两者混成一个「任务失败」,线上就会天天收到无意义的取消告警。

顺带说清 panic 的边界:任务里 panic 不会杀掉整个进程,只会让那个任务以 JoinError 结束;但如果没人 join,panic 就被吞掉了,日志里只剩一行 stderr,业务侧毫无感知。这就是「detach 的任务出错看不到」的具体机制。关键任务要么 join,要么在任务内部用 catch_unwind 或显式的 Result 把错误传出来。

取消:abort 不是立即生效

JoinHandle::abort() 请求取消任务,但取消是协作式的:任务只会在下一个 await 点被丢弃,正在执行的同步代码不会被打断。实测一个每 50 毫秒自增的任务,220 毫秒后 abort:

abort     => cancelled=true
abort     => before=4, after=4

abort 之后等待 300 毫秒,计数不再增长,说明任务确实被取消了。但注意 before=4:220 毫秒里只完成了 4 次,第 5 次还没到 await 就被取消,所以是 4。这个数字依赖调度,换台机器可能是 4 也可能是 5,不要把它当固定值。

如果任务里有「写文件写到一半」「发消息发到一半」这类操作,取消可能留下不完整的状态。tokio 的 future 在被 drop 时会执行已注册的清理,但不会帮你回滚业务副作用。需要「要么全做要么不做」的地方,要么把操作做成幂等,要么在取消后由上层补偿。这也是 select! 的坑:另一个分支赢了,输的 future 被 drop,它做到哪一步你并不知道。文档里把这种性质叫「取消安全」(cancel safety),用 select! 前要确认每个分支都取消安全。

timeout:返回 Err,不是杀任务

tokio::time::timeout 的语义是「等一段时间,如果内部 future 还没完成,就返回 Err(Elapsed)」。它不会杀线程,也不会让内部 future 继续跑;超时发生时,内部 future 被 drop,等同于取消。实测:

timeout   => elapsed

代码里写的是 timeout(80ms, sleep(300ms)),结果返回 Elapsed,整个过程约 80 毫秒。这个 API 适合「等网络响应、等锁、等队列」这类有明确上限的操作。要注意两点:第一,超时后内部 future 的副作用可能已经发生了一部分;第二,超时不是重试,重试策略、幂等性、退避都要自己设计。

还有一个容易混淆的点:timeout 只包住它包裹的 future。如果你的任务在 spawn 之后才被 timeout 包住,超时 drop 的是 JoinHandle,后台任务仍然在跑(因为 drop 不取消)。要真正停止,得显式 abort 并等待,或者用 timeout 包住任务本体而不是句柄。

阻塞混入:386 毫秒与 75 毫秒

回到开头的事故。下面这组对照在单线程 runtime 里跑:一个任务执行 std::thread::sleep(300ms),另一个任务 tokio::time::sleep(50ms) 后打印。先看阻塞调用直接写在 async 块里:

blocking  => 阻塞任务完成, 386.3997ms
blocking  => 定时器触发, 386.4681ms

定时器本来 50 毫秒就该触发,实际等到 386 毫秒,因为执行器线程被 thread::sleep 占住了,定时器事件没人处理。换成 spawn_blocking:

spawn_blk => 定时器触发, 75.0283ms
spawn_blk => 阻塞任务完成, 300.0967ms

定时器在 75 毫秒触发,阻塞工作在另一个线程上跑满 300 毫秒,两者互不干扰。这就是 spawn_blocking 的作用:把阻塞代码挪到专门的阻塞线程池,让异步 worker 继续驱动其他任务。

但 spawn_blocking 不是万能药。它的线程池有上限(默认远大于 worker 数,但不是无限),大量阻塞任务会把池子占满,后来的任务排队。它也不适合「短小但频繁」的操作,每次调度都有开销。真正的判断标准是:这个操作会不会阻塞超过一毫秒?会,就用 spawn_blocking 或独立线程;不会,就直接做。数据库驱动、文件 IO、图像处理、压缩,这些是典型的阻塞操作,要用异步版本的库,或者包进 spawn_blocking。选库时先看它是不是原生异步的,把同步驱动硬塞进异步上下文,迟早会在压测里暴露。

多线程 runtime 也不能免疫阻塞。worker 数量默认等于 CPU 核数,如果所有 worker 都被阻塞调用占住,新任务一样排队。阻塞不会「只影响一个线程」,它影响的是整个 runtime 的吞吐。

同步原语:别把 std 的锁带过 await

tokio 提供了自己的同步工具:tokio::sync::Mutex、RwLock、mpsc、oneshot、watch、Semaphore。它们和标准库的版本解决的不是同一个问题:tokio::sync::Mutex 允许跨 await 持有,因为它在等锁时会让出执行器;std::sync::Mutex 的 guard 通常不是 Send,跨 await 会被编译器拒绝。

那是不是所有地方都该用 tokio::sync::Mutex?不是。异步锁比同步锁贵,它要维护等待队列、唤醒任务。如果临界区里没有 await,用 std::sync::Mutex 更快,也更不容易把执行器拖住。经验规则:临界区里有 await 才考虑异步锁,没有就用标准库的锁,并且把 guard 的作用域压到最短。

通道的选择也类似。mpsc 适合多生产者单消费者,oneshot 适合「一次结果」,watch 适合「只关心最新值」的配置广播,broadcast 适合「每个订阅者都要收到每一条」。选错通道会导致语义问题,比如用 watch 传任务,消费者可能漏掉中间状态;用 broadcast 传配置,慢消费者会拖住整个通道。先想清楚「消息要保留几条、消费者慢了怎么办」,再选类型。

网络 IO 是 tokio 的主场。tokio::net::TcpListener 的 accept、TcpStream 的 read/write 都是 async 的,等待时不占线程。和标准库那篇相比,协议层的「粘包与分帧」一点没变:read 仍然只给你「当前可读的字节」,仍然要自己按长度或分隔符拼帧。tokio 只改变了「等待的方式」,没有改变「字节流的语义」。把这两层分清,就不会误以为换个运行时就能自动识别消息边界。

任务泄漏、限流与优雅停机

spawn 的任务如果没人等,出错也不会被发现。一个请求进来 spawn 一个后台任务,请求结束了任务还在跑,数据库连接、文件句柄、内存都占着。控制手段有三层:用 JoinSet 统一收集并等待;用 Semaphore 限制并发数;给任务设置超时或取消条件。三层都不做,短时间压测看不出问题,长时间运行就会积累。

限流不只是「防止打挂下游」,也是「保护自己的内存」。每个等待中的任务都占内存,无上限地接收请求,等于把队列长度交给攻击者决定。Semaphore 的许可数量应该根据下游容量和自身内存预算来定,而不是拍一个「1000」。这个数字最好来自压测和监控,而不是感觉。

停机时,runtime 退出会取消未完成的异步任务;已经开始的 spawn_blocking 闭包不会中途被打断,可能拖住退出。优雅停机的顺序通常是:停止接收新请求,等待在途任务完成(带超时),再关闭 runtime。需要保存状态的场景,还要在超时前把进度落盘。这些逻辑不在 tokio 里,要自己编排。

还有一个不常用的口子叫 block_in_place。它告诉多线程 runtime「当前 worker 要阻塞一会儿,把其他任务挪走」,适合无法拆成异步的短阻塞段。它只能在多线程 runtime 里用,而且会让 runtime 临时补充 worker,频繁调用会破坏调度。能用 spawn_blocking 就别用它;它更像是「实在没办法时的止损」,不是常规手段。

测试异步代码时,别真的睡几秒。tokio 的测试工具可以在「暂停的时间」上跑:时间只在任务让出时推进,sleep(5s) 瞬间完成,定时器顺序仍然可验证。用真实时间写测试,CI 会变慢且不稳定;用暂停时间,测试快,但要注意它不会模拟真实 IO 的延迟与抖动。两种测试都要有:逻辑顺序用暂停时间,端到端延迟用真实时间。

现象对照

现象真实原因第一步查什么
压测时 P99 突然变成秒级,CPU 不高某个任务里混入了阻塞调用,占住 worker搜 thread::sleep、同步 IO、同步数据库调用
定时器比预期晚很多才触发执行器线程被阻塞,事件循环停摆把阻塞工作移到 spawn_blocking
在 async 里建 runtime 直接 panic嵌套 runtime,block_on 占住外层线程删掉内层 runtime,用 spawn/spawn_blocking
spawn 报 future 不是 'static闭包借用了栈上变量加 move,共享状态用 Arc
spawn 报 future 不是 Send跨 await 持有 Rc/非 Send guard缩短持有范围,换 Arc/异步锁
abort 之后任务还在写数据取消只在 await 点生效,同步段不会被打断在关键步骤前后加检查点,设计幂等操作
超时返回了,后台任务还在跑timeout 包的是 JoinHandle,drop 不取消任务包住任务本体,或超时后显式 abort
服务跑久了内存一直涨detach 的任务越积越多,或通道无界用 JoinSet 管理,通道设上限,加 Semaphore
退出时卡住几十秒阻塞任务还在跑,或任务没有取消条件检查 spawn_blocking 与停机顺序,设置超时

边界与代价

第一层是「运行时选择」。tokio 是目前生态最全的运行时,但绑定它意味着库也要用 tokio 的 IO 和定时器;混用两个运行时会出问题。选运行时不是选一个依赖,是选一套 IO 模型和生态。小工具用 current_thread 足够,服务端才需要多线程调度。

第二层是「异步的传染性」。一个函数变成 async,调用它的地方也要 async,一路向上传。这不是缺点,是设计:异步边界要划在「IO 密集」的地方,不要把整个程序都变成异步。纯计算、配置解析、小工具,用同步代码更简单。

第三层是「调试与观测」。异步任务的调用栈不直观,任务之间没有父子关系,panic 只会杀掉那个任务,不一定让进程退出。要给任务起名字、记录任务开始与结束、统计队列长度和等待时间。tokio 提供了 task::Builder 命名和 tracing 集成,用不用取决于你对可观测性的要求。

第四层是「取消与一致性」。异步取消是常态,不是异常。任何跨 await 的多步操作,都要问「如果在第二步被取消,第一步的副作用怎么办」。答案通常是幂等、补偿、或者把多步操作放进一个不可取消的阻塞任务里。没有这个设计,取消就会变成数据不一致的来源。

小结

把这一篇收成四句:runtime 是执行器,#[tokio::main] 只是替你建了一个;spawn 的任务不是线程,要求 'static + Send,句柄 drop 不会取消任务;abort 和 timeout 都是协作式取消,只在 await 点生效;任何阻塞调用都要移出异步 worker,spawn_blocking 是工具,不是许可证。

这一组到这里就完整了:文件、网络、进程、线程共享、跨进程共享、异步模型、tokio。回头看会发现它们共享同一条主线:操作系统提供能力,Rust 提供类型约束,真正的语义(边界、同步、生命周期、取消)永远要自己设计。下一篇没有下一篇了,这里留一个建议:把这些例子改成一个小项目,比如一个带超时和并发限制的本地文件服务,比继续看文档有用得多。

当天可以自己验证的练习:

  1. 用 current_thread runtime 复现「定时器被 thread::sleep 拖到 300 毫秒后」,再用 spawn_blocking 对比。
  2. spawn 一个每 50 毫秒自增的任务,200 毫秒后 abort,确认计数停止,并解释为什么是 4 而不是 5。
  3. 用 timeout 包一个 JoinHandle,确认超时后后台任务仍在跑;再改成包任务本体,对比行为。
  4. 用 Semaphore 把并发限制到 5,启动 20 个任务,统计最大同时运行数。
  5. 在 async 块里跨 await 持有 std::sync::MutexGuard,把 future 放进 tokio::spawn,记录编译错误;再换成 tokio::sync::Mutex,确认能编译。

这五条跑完,再遇到「异步服务变慢」「任务取消不干净」「内存一直涨」,基本能按现象定位到具体那一层。