异步 Rust 的未来:async fn in trait 稳定后,生态会发生什么变化的预测
保持学习,保持输出。async fn in trait 终于要稳定了!作为一个每天跟 Future 和 Pin 较劲的 Rust 萌新,这事儿我盯了快半年了。
// 想写一个异步 trait,但编译器不让你这么写
trait DataFetcher {
async fn fetch(&self, url: &str) -> String; // 编译错误!
// error[E0706]: functions in traits cannot be declared `async`
}
然后搜索引擎告诉你:"用 async-trait 这个宏吧。"于是你写:
use async_trait::async_trait;
#[async_trait] // 宏生成的代码会把 async fn 转换成返回 Pin<Box<dyn Future>> 的形式
trait DataFetcher {
async fn fetch(&self, url: &str) -> String; // 宏展开后才能用
}
能用是能用了,但每次看到 Pin<Box<dyn Future<Output = String>> 这种类型签名,我都忍不住想问:为什么原生不支持呢?
好消息是,async fn in trait 正在稳定化的路上。这意味着上面那段代码很快就不需要 async-trait 宏了。但真正有意思的不是语法层面的变化,而是这个特性对 Rust 异步生态的深层影响。
一、async fn in trait 到底是什么?
对于刚接触这个概念的同学,我用一张图来解释 async-trait 宏方案和原生方案的区别:
简单来说,async-trait 给你的是"能用",原生方案给你的是"高效+优雅+灵活"。性能差异不是纸上谈兵——我们来看一段对比代码:
// ========== async-trait 方案 ==========
use async_trait::async_trait;
#[async_trait]
pub trait Service {
async fn call(&self, input: &str) -> String;
}
// 宏展开后,call 方法实际上变成了:
// fn call<'a>(&'a self, input: &'a str)
// -> Pin<Box<dyn Future<Output = String> + Send + 'a>>
//
// 问题:
// 1. Pin<Box<dyn Future>> —— 每次调用都要在堆上分配
// 2. dyn Future —— 虚函数调用,编译器无法内联
// 3. + Send + 'a —— 生命周期约束可能不满足
// ========== 原生方案(稳定后) ==========
pub trait Service {
async fn call(&self, input: &str) -> String;
}
// 编译器自动生成一个关联类型:
// trait Service {
// type CallFuture<'a>: Future<Output = String> + 'a
// where Self: 'a;
//
// fn call<'a>(&'a self, input: &'a str) -> Self::CallFuture<'a>;
// }
//
// 优势:
// 1. 关联类型是编译期确定的 —— 零堆分配
// 2. 静态分发 —— 编译器可以内联优化
// 3. 生命周期更灵活 —— 不强制 'static
在一个高频率调用 trait 方法的场景(比如 Web 框架的中间件链路),原生方案每个请求少做一次 Box::pin(),积少成多就是显著的吞吐量差异。
二、谁会最先受益?
async fn in trait 稳定后,以下几个领域的生态变化会最明显:
我来逐一分析:
Web 框架(axum/actix-web):Tower 的 Service trait 是目前异步 trait 使用的重灾区,大量使用 async-trait 宏。稳定后,Tower 可以移除对宏的依赖,中间件组合的性能会得到提升。
// Tower Service trait 的未来形态(示意)
use std::future::Future;
pub trait Service<Request> {
type Response;
type Error;
// 稳定后可以原生声明异步方法
async fn call(&self, req: Request) -> Result<Self::Response, Self::Error>;
}
// 中间件可以这样组合(不需要 Pin<Box<dyn Future>> 了)
pub struct TimeoutMiddleware<S> {
inner: S,
timeout: Duration,
}
impl<S, Req> Service<Req> for TimeoutMiddleware<S>
where
S: Service<Req>,
{
type Response = S::Response;
type Error = S::Error;
async fn call(&self, req: Req) -> Result<Self::Response, Self::Error> {
// 利用原生支持,不需要额外包装 Future
tokio::time::timeout(
self.timeout,
self.inner.call(req),
).await
.map_err(|_| /* 超时错误处理 */)?
}
}
数据库驱动(sqlx/sea-orm):数据库连接池、事务管理这些场景大量依赖异步 trait。原生支持后,不再需要为每个查询做额外的堆分配。
嵌入式 Rust(embassy):这是最引人注目的方向。async-trait 需要堆分配(Box),而嵌入式环境通常没有堆。原生支持让嵌入式 Rust 也能享受异步编程的便利,不需要任何运行时开销。
三、对普通开发者的影响:什么时候该切?
我的建议分为三个阶段:
// 第一阶段:现在(2026年7月)
// 继续用 async-trait,但要了解原生方案的进展
#[async_trait]
trait MyService {
async fn process(&self, data: &[u8]) -> Vec<u8>;
}
// 第二阶段:nightly 可用后(预计 2026年Q3)
// 在个人项目/实验项目中试用
#![feature(async_fn_in_trait)]
trait MyService {
async fn process(&self, data: &[u8]) -> Vec<u8>; // 原生支持!
}
// 第三阶段:stable 稳定后(预计 2026年底-2027年初)
// 生产项目中逐步迁移,享受零开销带来的性能提升
对于正在学 Rust 的同学,我的建议是:
- 现在继续用
async-trait,它很成熟,文档齐全,没有坑 - 理解背后的原理(
Pin、Future、状态机),原生方案只是让语法更自然,底层原理不变 - 关注 RFC 讨论,了解边界情况和限制,避免稳定后踩坑
// 用原生 async fn in trait 时,需要注意 Send 约束
use std::future::Future;
// 如果要在线程间传递,需要显式约束
pub trait AsyncProcessor {
async fn process(&self, data: String) -> String
where
// 编译器自动推断的关联 Future 类型需要满足 Send
Self: Send + Sync; // 确保 Future 可以跨线程
}
// 多线程环境下的正确用法
async fn run_processor(processor: Arc<dyn AsyncProcessor>) {
let handle = tokio::spawn(async move {
// processor 可以在任务间传递,因为满足了 Send 约束
processor.process("hello".to_string()).await
});
let result = handle.await.unwrap();
println!("处理结果: {}", result);
}
四、生态变化的三个趋势预测
基于我对 Rust 生态的观察,async fn in trait 稳定后会催生三个趋势:
趋势一:trait 定义大爆发
现在很多库为了避免 async-trait 的依赖和性能问题,选择用枚举代替 trait,或者直接用函数。原生支持后,异步 trait 会成为异步抽象的首选方式,库的 API 设计会更加自然。
趋势二:no_std 异步生态兴起
嵌入式 Rust 社区一直在等这个特性。没有堆分配的异步 trait 让 embassy、RTIC 这些嵌入式框架可以在不牺牲性能的前提下提供高层抽象。这可能是 Rust 在 IoT 和嵌入式领域的一个转折点。
趋势三:异步代码与非异步代码的边界模糊
// 未来可以更自然地混合同步和异步 trait
trait Storage {
// 同步方法:只需要读内存缓存
fn get_cached(&self, key: &str) -> Option<&[u8]>;
// 异步方法:需要访问磁盘或网络
async fn fetch_remote(&self, key: &str) -> Result<Vec<u8>>;
// 异步方法的默认实现可以调用同步方法
async fn get(&self, key: &str) -> Result<Vec<u8>> {
// 先查缓存(同步)
if let Some(data) = self.get_cached(key) {
return Ok(data.to_vec());
}
// 缓存未命中,远程获取(异步)
self.fetch_remote(key).await
}
}
同步和异步方法在同一个 trait 里共存,这在以前是需要宏才能做到的事情。这种"混搭"能力会让库的设计更加贴近真实业务场景——不是所有操作都需要异步,也不是所有操作都能同步完成。
五、总结
async fn in trait 的稳定化,虽然看起来只是一个语法层面的改进,但它对生态的影响是结构性的:
性能提升是实打实的。从动态分发到静态分发、从堆分配到栈分配,高频调用的场景下差异明显。对 Web 框架来说,这意味着更低的延迟和更高的吞吐。
嵌入式 Rust 才是最大赢家。no_std 环境下的异步编程因为 async fn in trait 而变得可行。这个市场虽然小众,但对 Rust 的"系统编程语言"定位至关重要。
迁移策略要稳。
async-trait至少还会是主流方案一年以上。作为学习者,理解原理比追新特性更重要。原生方案和宏方案的核心概念(Future、Pin、状态机)是完全一致的。我现在就开始用 nightly 试了。在自己的 side project 里体验一下原生方案的语法,等 stable 的那天就可以直接迁移。
保持学习,保持输出。异步 Rust 的未来看起来真的很好——尤其是对于我这种被 Pin<Box<dyn Future<...>>> 折磨过的选手来说。
资料说明
本文中的协议、版本、性能、成本和行业趋势应以可核验的一手资料为准。未标注统计口径的比例、时间表和预测仅作工程讨论,不应视为行业事实。可参考 0730 资料来源索引,并在发布前将具体来源贴到对应断言之后。
313



被折叠的 条评论
为什么被折叠?



