Rust 2026 经验谈 - 异步生态选型指南

Tokio：事实标准#

Tokio 是 Rust 异步生态中占有率最高的运行时，绝大多数 crate 优先支持 Tokio。

核心特性：

• multi-thread 工作窃取调度器
• 丰富的 I/O 驱动（TCP/UDP/Unix/pipe/signals）
• 完善的工具链（tokio-console、tracing 集成）
• 任务预算（task budgeting）防止活锁
• 成熟的生态：hyper、tonic、tower、reqwest 均基于 Tokio

适用场景：网络服务、微服务、gRPC/HTTP 后端、CLI 工具

弱点：

• 二进制体积大（启用 full features 后 2MB+）
• 编译时间长
• 对嵌入式不友好

1
# 典型 Tokio 依赖
2
[dependencies]
3
tokio = { version = "1", features = ["rt-multi-thread", "macros", "net", "time", "io-util", "signal"] }

async-std：标准库风格的异步#

async-std 的设计哲学是”异步版 std”——API 与标准库一一对应，学习成本最低。

核心特性：

• 与 std 一致的 API 命名（async_std::fs::read_to_string 对应 std::fs::read_to_string）
• 默认多线程调度器
• 基于 smol 的执行器（async-std 1.6+ 后内部用 smol 的 epoll 驱动）

适用场景：教学、原型、与 std 风格高度一致的项目

弱点：

• 社区活跃度下降，新功能跟进慢
• 生态不如 Tokio 丰富（无内置 HTTP/gRPC）
• 部分性能指标落后 Tokio（调度器优化较少）

1
[dependencies]
2
async-std = { version = "1", features = ["attributes"] }

smol：轻量级异步#

smol 是 async-std 核心作者 Stjepan Glavina 的轻量级运行时，代码量极小（核心 < 3000 行）。

核心特性：

• 极小的代码体积和编译时间
• 基于 epoll/kqueue/io_uring 的异步 I/O
• smol::block_on 无需全局运行时
• 灵活的 executor 模型

适用场景：库作者（不想强依赖 Tokio）、轻量工具、测试

弱点：

• 生态最弱——几乎没有基于 smol 的 HTTP/gRPC 库
• 文档和教程较少
• 社区规模小

1
[dependencies]
2
smol = "2"

定量对比#

结论：新项目默认选 Tokio，除非你有非常明确的理由选其他。

问题：库强依赖运行时#

1
// 反模式：库直接依赖 tokio
2
[dependencies]
3
tokio = { version = "1", features = ["full"] }
4

5
// 库代码
6
pub async fn fetch_data() -> String {
7
    tokio::time::sleep(Duration::from_secs(1)).await; // 绑定了 tokio
8
    String::from("data")
9
}

如果使用者用 async-std 或 smol，tokio::time::sleep 不会工作——Tokio 的定时器需要 Tokio 运行时。

原则一：generic over executor#

用 futures crate 提供的运行时无关原语：

1
// 正确：不依赖特定运行时
2
use futures::future::FutureExt;
3
use std::time::Duration;
4

5
// 用 trait 来抽象时间
6
// 注意：trait 中的 async fn 需要 Rust 1.75+（async fn in trait 已稳定）
7
pub trait Sleep {
8
    async fn sleep(duration: Duration);
9
}
10

11
// 库代码只依赖 trait
12
pub async fn fetch_data<S: Sleep>() -> String {
13
    S::sleep(Duration::from_secs(1)).await;
14
    String::from("data")
15
}

更实用的方式：直接用 futures 的组合子，避免 I/O 依赖：

1
// 纯计算 + futures 组合子：运行时无关
2
use futures::stream::StreamExt;
3

4
pub fn process_stream<S>(stream: S) -> impl futures::Stream<Item = Result<Data, Error>>
5
where
6
    S: futures::Stream<Item = RawData>,
7
{
8
    stream.filter_map(|item| async move {
9
        match process(item) {
10
            Ok(data) => Some(Ok(data)),
11
            Err(e) => Some(Err(e)),
12
        }
13
    })
14
}

原则二：用 feature flag 提供多运行时支持#

1
[features]
2
default = ["tokio-runtime"]
3
tokio-runtime = ["dep:tokio"]
4
async-std-runtime = ["dep:async-std"]
5

6
[dependencies]
7
tokio = { version = "1", optional = true }
8
async-std = { version = "1", optional = true }
9
futures = "0.3"

1
#[cfg(feature = "tokio-runtime")]
2
pub use tokio::net::TcpStream;
3

4
#[cfg(feature = "async-std-runtime")]
5
pub use async_std::net::TcpStream;

原则三：只在”叶节点”依赖运行时#

将运行时依赖推到应用的入口（main），而不是库的内部：

1
应用 main.rs (tokio)
2
  └── 你的库 (运行时无关)
3
        └── futures (运行时无关)
4
  └── 其他库 (tokio-specific I/O)

经验：如果你的库被 3 个以上项目使用，就应该做到运行时无关。内部项目可以强依赖 Tokio 节省开发时间。

为什么选 glommio#

glommio 是 DataDog 开发的基于 io_uring 的线程每核（thread-per-core）运行时，专为高 I/O 吞吐设计。

适用场景：

• 高吞吐文件 I/O（数据库存储引擎）
• 高吞吐网络 I/O（代理、CDN）
• Linux 5.6+ 环境
• 无需跨核心共享状态

基本用法#

1
use glommio::prelude::*;
2
use glommio::io::DmaFile;
3

4
fn main() {
5
    let executor = LocalExecutor::default();
6

7
    executor.run(async {
8
        // 打开文件（通过 io_uring）
9
        let file = DmaFile::open("large_file.dat")
10
            .await
11
            .expect("打开文件失败");
12

13
        // 直接 I/O 读取（绕过页缓存）
14
        let buffer = file.read_at_aligned(0, 4096)
15
            .await
16
            .expect("读取失败");
17

18
        println!("读取 {} 字节", buffer.len());
19

20
        file.close().await.expect("关闭文件失败");
21
    });
22
}

性能特征#

注：性能高度依赖于内核版本、NVMe 设备和 io_uring 配置。以上数据基于 Linux 6.1 + Samsung 980 Pro。

glommio 的限制#

1. 仅 Linux：io_uring 是 Linux 专属
2. 线程每核模型：不能跨核心共享 Glommio 的 task，需要通过 shard + channel 通信
3. 生态小：没有 HTTP 框架、ORM、gRPC 库
4. 调试困难：无 tokio-console 类似工具
5. API 稳定性：glommio 还在 0.x，API 可能变更

集成模式：Tokio + glommio#

可以在 Tokio 应用中用 glommio 处理 I/O 密集部分：

1
use tokio::task;
2

3
async fn hybrid_approach() {
4
    // 网络处理：Tokio（生态丰富）
5
    let network_result = tokio::spawn(async {
6
        // HTTP 请求、gRPC 调用等
7
        reqwest::get("https://api.example.com/data").await
8
    });
9

10
    // 文件 I/O：glommio（高性能）
11
    let io_result = task::spawn_blocking(|| {
12
        let executor = glommio::LocalExecutor::default();
13
        executor.run(async {
14
            // glommio 的文件操作
15
            heavy_file_io().await
16
        })
17
    });
18

19
    let (net, io) = tokio::join!(network_result, io_result);
20
}

为什么嵌入式需要异步#

传统嵌入式用中断 + 状态机，代码可读性差且难以组合。embassy 将 Rust async/await 带入 no_std 环境，用协作式调度替代抢占式调度，效率更高。

核心架构#

1
#![no_std]
2
#![no_main]
3

4
use embassy_executor::Spawner;
5
use embassy_stm32::peripherals::PA5;
6
use embassy_time::Timer;
7
use embedded_hal_async::digital::Wait;
8
use embassy_stm32::gpio::{Level, Output};
9

10
#[embassy_executor::main]
11
async fn main(spawner: Spawner) {
12
    let p = embassy_stm32::init(Default::default());
13

14
    let mut led = Output::new(p.PA5, Level::High, embassy_stm32::gpio::Speed::Low);
15

16
    loop {
17
        led.set_high();
18
        Timer::after_secs(1).await;
19
        led.set_low();
20
        Timer::after_secs(1).await;
21
    }
22
}

embassy 的优势#

embassy 的生态#

• embassy-stm32：STM32 全系列 HAL
• embassy-nrf：Nordic nRF52/nRF53 HAL
• embassy-rp：Raspberry Pi Pico (RP2040/RP2350) HAL
• embassy-usb：USB 设备栈
• embassy-net：TCP/IP 栈（基于 smoltcp）

注意事项#

1. embassy 不用 Tokio——它有自己的执行器（embassy-executor），专为 no_std 设计
2. Flash 和 RAM 开销：embassy 的 Future 状态机比手写状态机大，注意检查 .map 文件
3. 调试手段有限——无 tokio-console，依赖 defmt 日志和 probe-rs

具体建议#

1. Web 后端（HTTP/gRPC）：Tokio + axum/tonic，无悬念
2. 数据库存储引擎：glommio（如果 Linux + 高 IOPS）或 Tokio
3. CLI 工具：Tokio（生态最全）或 smol（编译快）
4. 库开发：executor-less + feature flags
5. 嵌入式：embassy
6. 教学/原型：async-std（API 与 std 一致，学习成本最低）
7. 高性能计算：Tokio + rayon 异步+同步混合

从 async-std 迁移到 Tokio#

1
// async-std
2
async_std::task::spawn(async { ... });
3
async_std::fs::read_to_string("file.txt").await?;
4
async_std::net::TcpStream::connect(addr).await?;
5

6
// Tokio 等价
7
tokio::spawn(async { ... });
8
tokio::fs::read_to_string("file.txt").await?;
9
tokio::net::TcpStream::connect(addr).await?;

主要差异：

• async_std::task::spawn 不要求 Send（local task），tokio::spawn 要求 Send
• async_std::main 默认多线程，tokio::main 需要显式 flavor = "multi_thread"
• 定时器 API 略有不同

从 Tokio 迁移到 smol#

不推荐。smol 的生态远不如 Tokio，除非你的项目非常简单。迁移代价主要是替换所有 tokio::* 调用，且很多 Tokio 生态的 crate（hyper、tonic）无法在 smol 上使用。