Rust异步实战:tokio与async/await打造高并发AI推理服务
这两年在做 AI 应用落地时,我越来越常碰到一个组合:Rust + async/await + tokio。AI 开发这行当有个特点,早期大家靠 Python 一把梭,但一旦涉及高并发推理服务、模型网关、多路视频流预处理、实时特征管道这类场景,Python 的性能和并发模型就开始吃力。Rust 的 async/await 配合 tokio 异步运行时,几乎成了工业级 AI 基础设施的标准选择。这一课我打算聊透 tokio 的实战用法,不光是讲语法,而是从“为什么需要异步”“tokio 内部怎么跑”“写 AI 服务时怎么用好它”三个角度展开,全程用例子说明。
内容适合正在转 Rust 的 AI 应用开发工程师、准备搞 LLM 网关和推理服务的后端开发,以及想把自己 Python 并发代码性能瓶颈解决的同行。读完你能建立起一套完整的 async/await + tokio 心智模型,并且能照着代码落地自己的异步服务。
1. 先搞懂 Rust 异步模型:async/await 到底解决什么问题
1.1 从线程到异步:为什么 AI 场景必须换赛道
在进入 tokio 之前,得先想清楚一个问题:为什么 AI 开发里线程池不够用?
早期我也用过线程池处理并发推理请求——每个 HTTP 请求来了就丢给一个工作线程,模型推理是 CPU 密集型的,感觉没毛病。但现代 AI 应用的瓶颈根本不是 CPU 计算,而是 I/O 等待。举几个实测场景:
- 请求一个外部模型 API(比如 OpenAI、Claude),网络往返要 200-2000ms,期间线程完全在闲着;
- 读取向量数据库、Redis 缓存、对象存储,磁盘和网络延迟不可控;
- 多路视频帧的预处理管道,需要同时读取多路流并做异步帧同步。
如果每个请求占一个线程,1000 个并发请求就需要 1000 个线程。每个线程默认栈空间 2MB,光是内存就压掉 2GB;而且线程切换在内核态,上下文切换开销在重负载下会吃掉 30% 以上的 CPU。更要命的是,AI 服务还需要同时承载 GPU 推理任务的调度、数据管道的调度,这种场景下纯线程模型很容易把资源耗尽。
Rust 的 async/await 是 协作式多任务 模型:一个线程上可以跑成千上万个"任务"(task),每个任务在遇到 I/O 等待时主动让出 CPU(await 点);等 I/O 完成后再被唤醒继续跑。这样线程数量可以压到和 CPU 核心数相当,剩余的全是内存里轻量级的状态机。用生活类比就是:线程像雇了一百个服务员,每个服务员只服务一桌客人,客人一慢就干等;async 像是几个服务员来回服务多桌,点完菜就去倒水,充分利用时间。
1.2 Future 与 Poll:Rust 异步的最小本质
Rust 的 async 没有像 Go 那样自带 goroutine,它是通过 Future trait 实现的。简单说,一个 Future 是一个状态机,表示“一个可能还没完成的计算”。
当 poll 返回 Poll::Ready(val),任务完成;返回 Poll::Pending,任务还没就绪,需要继续等待。这里的 Context 里带着 waker,是关键的唤醒机制:I/O 准备就绪时,异步运行时通过 waker 把任务重新放回调度队列。
AI 开发人员不需要手写 poll,日常写的是 async fn 和 .await:
async fn call_model 其实是在编译时展开成一个隐藏的 Future 结构体,里面有 poll 的完整状态机实现。.await 就是让出点:系统先检查 Future 是否完成,没完就挂起,把控制权还给运行时;完成就接着往下执行。
明白了这点,就理解了 Rust 异步的核心特征:Rust 的 async 很“抠门”,它只做最小的调度开销,所有状态都显式放在 Future 结构体里。这意味着它适合性能敏感场景,但代价是数据结构复杂、使用难度高,所以 tokio 这类运行时才成为刚需。
2. tokio 运行时拆解:Work-Stealing 调度与现代异步服务基石
2.1 tokio 是什么:不止是事件循环
很多从 Node.js 转过来的同学以为 tokio 就是事件循环,这理解不够。tokio 是一整套异步运行时,核心包含三部分:
- 多线程工作窃取调度器(work-stealing scheduler):默认起 N 个工作线程(通常等于 CPU 核数),每个线程有独立的任务队列。某个线程队列空了,就去其他线程“偷”任务来执行,实现自动负载均衡。
- 底层 I/O 驱动(reactor):负责监听 socket、pipe、文件描述符的就绪事件,通过 epoll/kqueue/IOCP 等系统机制实现真正的事件驱动 I/O,实现非阻塞网络读写。
- 时间轮计时器(timer wheel):实现
tokio::time::sleep、timeout、interval 等定时功能,用高效的时间轮结构在 O(1) 时间内找到最近到期的定时任务。
正是这个组合决定了 tokio 能扛住高并发。比如一个 LLM 网关服务,同时挂着 5 万个 SSE 连接,每个连接等模型生成 token;如果用线程模型,光线程内存就顶不住;用 tokio,这些连接对应的 Future 只是内存里的几个状态机,工作线程数哪怕只有 8 个也能稳定跑。
2.2 关于 runtime 配置的关键参数
tokio 的 Runtime 是可以配置的,实战中这是第一个要重视的地方。
这里几个参数的注意点:
worker_threads默认是 CPU 逻辑核心数。但对 AI 推理服务,建议设置为核心数 - 1或核心数 / 2,因为要给 GPU 驱动线程、绑定 CPU 的预处理器留空间,避免 CPU 资源争抢导致 GPU 喂不满。max_blocking_threads控制阻塞线程池上限。后面讲spawn_blocking时会用到,拉太高容易失控,默认 512 一般够用。thread_stack_size对 AI 推理栈深的任务很重要。部分 C/C++ 底层库调用栈很深(比如某些 ONNX 推理优化库),默认 2MB 栈会爆栈,建议调到 4-8MB。- 固定线程名非常有用,排查问题的时候
top -H一眼就能区分 tokio 线程和模型推理线程。
2.3 Future 是惰性的:必须在运行时里才能驱动
刚接触 async Rust,容易踩一个经典坑:调用一个 async fn,以为它开始执行了,其实啥都没发生。Future 是惰性的——不 poll 它就永远不跑。
正确的做法有几种:
这个“惰性”特性放在 AI 场景里有实际影响——如果服务启动时要从对象存储拉模型或向量索引,别简单地 async fn load() 然后忘驱动,很容易出现模型还没加载完请求就进来导致 502。合理做法是启动阶段用 block_on 或者管理好的 JoinHandle 等待加载完成再开放流量。
3. AI 推理服务的 tokio 实战:从 HTTP 网关到任务编排
3.1 先搭一个带 tokio 的 AI 推理 HTTP 服务
我拿一个中小自研公司最常见的场景——内嵌模型的推理 HTTP 服务——来完整演示。选型思路:Web 框架用 axum(tokio 生态里的主流选择),模型推理用一个模拟的 Model 结构体代表(实际可以换成 ONNX Runtime、Candle 或者通过 reqwest 调外部 API)。
Cargo.toml 关键依赖:
我一般用 features = ["full"] 省心,线上再按需裁剪。tracing 必装,异步服务的日志追踪必须结构化,否则排查并发问题时会疯掉。
核心服务代码结构:
这段代码背后有几个重要设计考量,是实际 AI 服务里排过坑才总结出来的:
- 模型实例用
Arc<Model>:模型对象通常几十上百 MB,不能每请求复制一份。Arc 让多任务共享所有权,引用计数的开销可忽略。 - Semaphore 信号量必须用
acquire_owned:我见过不少人用acquire(),它要求 future 生命周期和 permit 借用一致;在 axum 这种场景里 borrow checker 会很别扭。用acquire_owned配合 Arc 信号量,permit 的所有权直接转移给任务,代码反而简单。这个信号量本质是做 背压(backpressure):并发请求超过模型承载能力时,多余请求直接排队而不是冲垮服务。 - 每个 await 点都是潜在的取消点:一个请求被客户端断开、或超时取消时,tokio 会在下一个 await 点安全地丢掉这个 future,状态全部清理。这是 async 模型比线程模型优雅的地方——不需要手动终止线程。
3.2 多路模型调用并发编排:join! 与 select!
AI 服务里最常做的一件事是“同时请求多个东西再合并结果”。比如一个 RAG 查询服务,需要同时:
- 查向量数据库找相关 chunk;
- 查 Redis 里的记忆上下文;
- 查用户画像数据。
这三个 I/O 之间没有依赖关系,应该并发执行。tokio 的 join! 宏就是干这个的:
注意 join! 是 等待所有任务完成 才会返回。对于 RAG 场景这个语义是对的:所有上下文都齐了才能拼 prompt。但如果是“取最快可用结果”,该用 select!:
这在做“模型降级路由”的时候非常实用:两个模型同时请求,谁先返回用谁(另一个直接取消)。LLM 基座网关的智能路由、超时快速失败,核心逻辑就是 select! + timeout。
值得提醒的是:join! 有最多 4 任务以内的性能较好;超过 4 个时可以考虑 FuturesUnordered。AI 场景里“批量并发调用”非常常见,比如一次请求要调 20 个 embeddings API,这时用 FuturesUnordered 更合适:
FuturesUnordered 的好处是所有并发任务共享同一个容量,谁先完成谁先被 poll,不会像 buffer_unordered 那样严格保持顺序而阻塞后续任务。做批量 embedding 时,吞吐能明显改善。
3.3 阻塞任务与 CPU 密集任务的正确处理
这是 AI 开发用 tokio 踩坑率最高的一节。tokio 的工作线程是给 I/O 异步任务用的,绝对不要在 async 上下文里跑 CPU 密集推理(比如 ONNX Runtime 的 session.run())。原因很简单:一旦一个 worker 线程进入 CPU 密集计算,它就没法响应 I/O,相当于这个线程上的所有异步任务都被冻住了。你的推理函数占 10 秒跑,其他几百个网络请求也就等 10 秒。
做法分两种情况:
情况一:同步库(ONNX、TFLite、tokenizer),直接调 spawn_blocking
spawn_blocking 会把任务丢给 tokio 的专用阻塞线程池,每次调用创建一个任务,独立的核心数足够时不会互相拖累。注意返回的是一个 JoinHandle,必须在 await 后处理嵌套 Result(外层是 join 错误,内层才是你的返回值或 panics)。
情况二:Candle、Burn 等原生 async 友好的推理库
更现代的做法是用专门绑定 CPU 核心的子线程处理推理,通过 channel 通信。tokio 里可以这样建立:
这种模式的本质是把推理线程独立出来,不让它阻塞异步工作线程;反过来,异步工作线程只负责接收请求、拼参数、转发结果。AI 网关和推理服务之间的解耦就是这种模式。这也是 NVIDIA Triton、TensorRT-LLM 这类框架的社区惯用手法。
有个细节:如果推理库里有 GPU 调用,注意 CUDA context 必须在同一个线程上初始化。用 spawn_blocking 每次新建线程的话,CUDA context 初始化的开销会重复计算,还可能出现显卡内存泄漏。建议服务启动阶段就把 CUDA context 初始化和模型加载放在一个固定的阻塞线程里完成,后续所有推理任务通过 channel 发给它,而不是每次 spawn_blocking。
3.4 超时控制:给 AI 调用加保险丝
模型 API 是不可靠的,特别是外部大模型,超时是常态。tokio 提供 timeout 函数,可以用最简单的写法给任何 future 加时间上限:
这里有个值得注意的语义:超时后,call_llm 这个 future 会被丢弃(drop)。如果 call_llm 内部用的是 reqwest,底层连接会被关闭,不会泄漏。但如果你在 future 里持有某种需要手动清理的资源(比如信号量 permit、锁),drop 时会自动释放,不会死锁。这就是 Rust 所有权机制对异步编程的降维打击——资源安全是编译期保证的。
做 AI Agent 开发时,超时不是只有一个总超时,往往是分层超时。我常用的实践是:
- 外部模型调用:单次 15 秒;
- Agent 多轮计划+工具调用:总超时 60 秒,内部每轮工具调用 10 秒;
- 每个 await 点再包一层
timeout,防止模型 response stream 卡住半天不发数据(SSE 的 keep-alive 包如果没有,客户端永远等不到流结束)。
这种“空闲超时”的处理模式,我实际用在 LLM 流式响应网关里,效果非常稳。SSE 连接挂死这个坑,几乎每个做 LLM 网关的团队迟早会遇到。
4. 错误处理、取消安全与结构化并发
4.1 async 下的错误处理风格
在 async 代码里写错误处理,和同步代码有个微妙差别:你不能依赖 ? 运算符随意传播,因为 async 函数返回的是 future,? 传播实际是“让 future 提前返回 Err”。这个模式没问题,但要小心 部分执行副作用。比如:
每个 ? 如果失败,future 会立刻 drop,它内部的局部状态随之释放,包括可能已经获取的信号量 permit、打开的 socket。这没问题。但如果有类似于 “记录日志” “更新计数” 的副作用,注意它们也可能会被跳过,可能不是你期望的行为。
AI 服务里更偏好用自定义错误类型,加上 thiserror 或 anyhow。我的实践是:库代码用 thiserror 定义错误域,Web 层用 anyhow 包一层便于统一日志。async 代码里尤其要把错误信息带上上下文(哪个模型、哪个 prompt 前缀、哪一步),因为并发场景下日志一多,没有上下文的报错基本等于没报。
4.2 “取消安全”是个容易被忽略的工程话题
Rust 里一个 future 可以被随时 drop(比如超时、客户端断开),这就是“取消”。取消是瞬时的、静默的、配合 RAII 自动生效的。但取消安全(cancel safety)不是自动的——如果 future 在 await 之前做了一半改动全局状态,然后被取消,这状态可能处于不一致的中间态。
典型的非取消安全操作是:
tokio::sync::Mutex::lock():锁已经获取,但 future 在后续 await 时被取消,锁没释放?实际上 tokio 的 MutexGuard 是 RAII,取消时自动释放,没毛病。问题出在“获取锁之后、await 之前”你已经改了共享数据。- 手动改一个
Vec或者HashMap进行到一半; - 发送了一个非幂等请求,但还没等响应。
在 AI 服务里常见的例子是流式输出:你给客户端发了一段文字,但用户中断了 prompt。这时未来被取消,但你可能已经在缓冲里写了一半输出。对此我用两种策略:
- 把状态变更封装在同步块里完成,不要跨 await 修改共享状态;
- 必须跨 await 改状态时,用结构化并发(
JoinSet或TaskGroup)保证要么全做要么全不做。
下面这个 JoinSet 的例子展示了“等待所有子任务完成并收集结果”的模式,非常适合 AI 里批量调用:
JoinSet 的好处是能追踪每个子任务的返回/失败/panic,并且在 Drop 时会取消所有尚未完成的任务。它比单纯 spawn 一堆 task 然后各种 JoinHandle 组合更可控,是 AI 任务编排的最佳实践之一。
4.3 任务泄漏:spawn 了就得有人管
我经常在代码 review 里看到一堆 tokio::spawn,spawn 完就不管了。这在 AI 服务里埋下隐患:任务如果内部有死循环或长等待(比如监听了一个 channel 但 sender 全掉了),任务会永远挂着。tokio 的任务本身占用内存,多了就内存泄漏;更重要的是某些共享资源(连接池、信号量)一直被占着,整个服务慢慢退化。
建议:每个 spawn 必须有归宿。简单场景用 JoinHandle;复杂编排用 JoinSet;需要向外发消息的用 mpsc::Sender 持有。我见过一个线上事故,某团队用 spawn 发外部请求,500 个请求打到一个已经没有监听者的 mesh 服务上,那个 channel 消息被 tokio 静默丢弃——这类 bug 只有任务日志、指标报警才能抓到。
给 AI 服务加一个“运行中任务数”指标,是最便宜的任务泄漏检测手段:
这个监控指标无论是接 Prometheus 还是打进日志做分析,都非常管用。
5. 实操:手写一个完整的 async AI 任务编排组件
前面零散地讲了很多点,这一节把核心技巧串成一个完整可运行的“AI 异步任务编排”组件。假设业务是:收到一个请求,先并行做 3 件事(检索、缓存、画像),然后拼 prompt 调 LLM,最后把结果写入队列。
完整依赖:
完整代码:
这个例子把前面讲的核心都串起来了:Semaphore 控并发、join! 并行等待、timeout 保护、mpsc 解耦产出、后台任务消费。跑一遍看日志,你会清楚看到每个阶段耗时和整体编排逻辑。
值得特别解释的是 with_timeout 的类型设计:它返回 Result<Result<T, Error>, Elapsed>,外层是“超时是否发生”,内层是“原始任务是否失败”。这样调用方可以用 ??? 明确区分超时错误和业务错误,在日志里能精确定位是模型卡了还是业务参数不对。这是实战里打磨出来的模式,比直接 timeout(...).await? 然后笼统返回错误信息好用得多。
6. 常见问题速查表:tokio 实战避坑指南
下面是我在 AI 后端服务开发里反复踩过、也在团队 code review 里常看到的典型问题,整理成速查表。
| 症状 | 根因 | 解决方案 |
|---|---|---|
| tokio worker 线程 CPU 100% 但吞吐极低 | 异步上下文里跑了 CPU 密集推理 | 用 spawn_blocking 或独立推理线程 |
| 所有请求莫名 408/超时 | 没有给外部模型调用加 timeout | 统一用 timeout 包装所有 .await 点 |
| 内存持续上涨 | spawn 出来的 task 没有正确终结 | JoinSet/FuturesUnordered 统一编排,监控任务数 |
| 模型 API 偶发连接泄漏 | 每次请求新建 reqwest Client | 用 Client 单例 + 连接池 |
| CUDA 内存泄漏 | 每个 spawn_blocking 线程各建 CUDA context | 固定线程初始化后反复使用 |
| 高峰期请求排队不均衡 | 多个 worker 线程的队列各自独立又不等长 | 综合调整 worker_threads 数量与调度策略 |
| 流式输出卡死 | SSE 连接挂死无人检测 | select! + 空闲超时(stream idle timeout) |
| 共享状态数据错乱 | 同一个 HashMap/Vec 被多个任务并发修改 | 不用 Arc 而是用 tokio::sync 的 actor/channel 模式 |
| 请求偶尔 500 且有 panic 日志 | 任务内部 unwrap/expect 崩溃 | JoinHandle 统一捕获 JoinError,配 tracing 错误追踪 |
| runtime 启动后马上退出 | 主线程 block_on 前后没持住运行时 | 用 #[tokio::main] 或 Runtime 对象持到服务结束 |
其中几个典型问题的展开:
问题一:worker 线程 100% 但吞吐上不去
排查方法:先看线程栈。top -H -p <pid> 后 gdb attach,看一下 worker 线程是不是卡在某个 CPU 密集符号(比如 onnxruntime::Session::Run)。如果是,就把推理挪出 async 上下文。用 tokio::task::flatten 不行,直接 spawn_blocking 移动语义传入数据,把结果带回。
问题二:超时后任务内存没释放
有些团队的超时处理是:“超时后继续等,过几分钟再检查结果”,这其实是把任务泄漏了。超时就该把 future drop,不能再等它跑完。如果你是想“后台继续跑但前端不阻塞”,应该改成另一条异步线程跑并通过 channel/store 回结果,而不是在 timeout 里泄漏 future。
问题三:Arc<Mutex<Vec>> 这种共享状态模式的性能瓶颈
AI 服务里常见“一个全局队列,多个消费者”,用 Arc<Mutex<Vec>> 做并不高效。tokio 的 std::sync::Mutex 在 await 持锁是会阻塞线程的。替代方案优先用 tokio::sync::Mutex(跨 await 持锁安全),更推荐用 mpsc::channel + actor 模式,把共享数据封装在一个 task 里,并发操作转成消息,这样消除了锁竞争,也让内存模型更清晰。我在写 Agent 工具调度器时就用 actor 模式,一个 manager task 管理所有工具的状态,其他 worker 只发消息,跑起来非常顺。
7. 最后补充:把 tokio 用好,AI 开发的编码体验会提升一个档次
写到这里想分享一点个人体会。很多人觉得 async Rust 学习曲线陡峭,实话说,和 Go 的 goroutine 确实没法比——Rust 给了你太多控制权,也就给了你太多要操心的细节。但对 AI 后端开发来说,这种“操心”值得。因为 AI 服务的核心矛盾就是高并发下的可控延迟与资源管理,而 Rust 的 async 模型在编译期就把数据竞争、资源泄漏、取消安全等一大批运行时问题提前堵死了。tokio 则把底层 I/O、定时器、调度器、阻塞线程池这些基础设施做得非常专业,让我能专注于业务逻辑。
如果读完只带走三句话,我希望是:
- I/O 等待多、并发要求高的 AI 服务,一律用 tokio 异步运行时,线程模型不是不能用,但资源效率差一个数量级。
- CPU 密集的模型推理永远不要直接放在 async 上下文里跑,用 spawn_blocking、独立推理线程或外部推理服务解耦。
- 每个 await 点都要想清楚“谁取消我、我取消谁、超时怎么办”,这块想清楚了,线上服务的稳定性能大幅提升。
后续你可以顺着这个方向继续玩:用 axum 暴露流式 SSE 接口、写一个简单的 LLM 网关做多模型路由、或者把 tokio 和 candle 结合写一个本地的 RAG 推理服务。这课的代码我全部实测过,直接放到自己的服务里改改就能用。