async 关键字 ​

核心概念 ​

async 是 Rust 中用于定义异步操作的关键字。它可以修饰函数(async fn)或代码块(async { }),将其中的代码转换为一个实现了 Future trait 的状态机。async 标记的代码不会立即执行——调用一个 async fn 只是创建了一个 Future 对象,真正的执行要等到这个 Future 被一个异步运行时(runtime)轮询(poll)时才会发生。这种"先描述后执行"的模式是 Rust 异步编程的基础。async 和 await 总是成对使用:async 创建 Future,await 等待 Future 完成。

rust
// 需要异步运行时,这里用 tokio 作为示例
// Cargo.toml 中需要:tokio = { version = "1", features = ["full"] }

use tokio::time::{sleep, Duration};

// async fn 定义一个异步函数
// 返回类型看起来是 String,实际返回 impl Future<Output = String>
async fn greet(name: &str) -> String {
    // 模拟异步操作(如网络请求)
    sleep(Duration::from_millis(100)).await;
    format!("Hello, {}!", name)
}

#[tokio::main]
async fn main() {
    // 调用 async fn 不会立即执行,只是创建了一个 Future
    let future = greet("Rust");

    // .await 才会真正执行
    let result = future.await;
    println!("{}", result);

    // 通常直接写成一行
    let msg = greet("World").await;
    println!("{}", msg);
}

async 的本质:语法糖 ​

rust
use std::future::Future;

// 这个 async fn:
async fn add(a: i32, b: i32) -> i32 {
    a + b
}

// 编译器本质上将它转换为类似这样的代码:
// fn add(a: i32, b: i32) -> impl Future<Output = i32> {
//     async move { a + b }
// }

// 两者的使用方式完全相同
// async fn 只是更简洁的写法

// 手动返回 Future 的写法
fn multiply(a: i32, b: i32) -> impl Future<Output = i32> {
    async move {
        a * b
    }
}

#[tokio::main]
async fn main() {
    let sum = add(3, 4).await;
    println!("3 + 4 = {}", sum);

    let product = multiply(3, 4).await;
    println!("3 * 4 = {}", product);
}

async fn 与普通函数的区别 ​

rust
use tokio::time::{sleep, Duration};

// 普通函数:调用时立即执行,阻塞当前线程
fn sync_work() -> String {
    // std::thread::sleep 会阻塞线程
    std::thread::sleep(Duration::from_millis(100));
    "同步完成".to_string()
}

// async fn:调用时不执行,返回 Future
async fn async_work() -> String {
    // tokio::time::sleep 不阻塞线程,只暂停当前任务
    sleep(Duration::from_millis(100)).await;
    "异步完成".to_string()
}

#[tokio::main]
async fn main() {
    // 同步函数:立即执行并返回结果
    let result = sync_work();
    println!("{}", result);

    // 异步函数:先创建 Future,await 后才执行
    let future = async_work();  // 此时什么都没发生
    println!("Future 已创建但尚未执行");
    let result = future.await;  // 现在才执行
    println!("{}", result);
}
特性普通函数 fn异步函数 async fn
调用时立即执行返回 Future,不执行
执行时机调用即执行.await 或被 poll 时
阻塞行为阻塞当前线程只暂停当前任务
返回值Timpl Future<Output = T>
可用上下文任何地方任何地方(但 await 只能在 async 中)

async fn 的参数和返回值 ​

rust
use tokio::time::{sleep, Duration};

// 带参数的异步函数
async fn fetch_user(id: u32) -> String {
    sleep(Duration::from_millis(50)).await;
    format!("用户_{}", id)
}

// 返回 Result 的异步函数
async fn try_connect(addr: &str) -> Result<String, String> {
    sleep(Duration::from_millis(50)).await;
    if addr.starts_with("valid") {
        Ok(format!("已连接到 {}", addr))
    } else {
        Err(format!("无法连接 {}", addr))
    }
}

// 返回 Option 的异步函数
async fn find_item(name: &str) -> Option<(String, f64)> {
    sleep(Duration::from_millis(30)).await;
    match name {
        "苹果" => Some(("苹果".to_string(), 5.5)),
        "香蕉" => Some(("香蕉".to_string(), 3.0)),
        _ => None,
    }
}

// 无返回值的异步函数
async fn log_event(event: &str) {
    sleep(Duration::from_millis(10)).await;
    println!("[日志] {}", event);
}

#[tokio::main]
async fn main() {
    // 基本调用
    let user = fetch_user(42).await;
    println!("{}", user);

    // Result 处理
    match try_connect("valid://db").await {
        Ok(msg) => println!("{}", msg),
        Err(e) => println!("错误: {}", e),
    }

    // ? 操作符在异步函数中正常工作
    async fn connect_and_query() -> Result<String, String> {
        let conn = try_connect("valid://db").await?;
        Ok(format!("{} → 查询完成", conn))
    }

    println!("{}", connect_and_query().await.unwrap());

    // Option 处理
    if let Some((name, price)) = find_item("苹果").await {
        println!("{}: {}元", name, price);
    }

    // 无返回值
    log_event("程序启动").await;
}

async 的惰性特性 ​

rust
use tokio::time::{sleep, Duration, Instant};

async fn expensive_computation(id: u32) -> u32 {
    println!("  [{}] 开始计算", id);
    sleep(Duration::from_millis(200)).await;
    println!("  [{}] 计算完成", id);
    id * 100
}

#[tokio::main]
async fn main() {
    // === 惰性:创建 Future 不会执行 ===
    println!("=== 惰性验证 ===");
    let f1 = expensive_computation(1);
    let f2 = expensive_computation(2);
    println!("两个 Future 已创建,但没有任何输出");

    // 只有 await 时才执行
    let r1 = f1.await;
    let r2 = f2.await;
    println!("结果: {}, {}\n", r1, r2);

    // === 顺序 await vs 并发 await ===
    println!("=== 顺序执行 ===");
    let start = Instant::now();
    let a = expensive_computation(10).await;  // 等200ms
    let b = expensive_computation(20).await;  // 再等200ms
    println!("顺序: {} + {} = {}, 耗时: {:?}\n", a, b, a + b, start.elapsed());
    // 约 400ms

    println!("=== 并发执行 ===");
    let start = Instant::now();
    // tokio::join! 同时驱动多个 Future
    let (a, b) = tokio::join!(
        expensive_computation(10),
        expensive_computation(20)
    );
    println!("并发: {} + {} = {}, 耗时: {:?}", a, b, a + b, start.elapsed());
    // 约 200ms
}

async 与生命周期 ​

rust
// async fn 中借用参数时涉及生命周期
// 编译器会自动推断,但某些场景需要注意

// 这个函数的 Future 借用了 name 的引用
// Future 存活期间,name 必须有效
async fn process(name: &str) -> usize {
    // 模拟处理
    name.len()
}

// 返回 impl Future 时需要显式标注生命周期
fn process_explicit<'a>(name: &'a str) -> impl std::future::Future<Output = usize> + 'a {
    async move {
        name.len()
    }
}

#[tokio::main]
async fn main() {
    let result = process("hello").await;
    println!("长度: {}", result);

    let name = String::from("Rust");
    let result = process(&name).await;
    println!("长度: {}", result);

    // name 在 Future await 完成前必须有效
    // 下面的代码可以工作,因为 name 活得足够久
    let len = process_explicit(&name).await;
    println!("显式生命周期: {}", len);
}

基本示例 ​

用 async 构建一个模拟的并发数据获取系统:

rust
use tokio::time::{sleep, Duration, Instant};

// 模拟从数据库获取用户
async fn fetch_user(id: u32) -> Result<String, String> {
    sleep(Duration::from_millis(150)).await;
    if id == 0 {
        Err("用户不存在".to_string())
    } else {
        Ok(format!("用户_{}", id))
    }
}

// 模拟从缓存获取配置
async fn fetch_config(key: &str) -> String {
    sleep(Duration::from_millis(80)).await;
    format!("{}=default_value", key)
}

// 模拟检查权限
async fn check_permission(user: &str, action: &str) -> bool {
    sleep(Duration::from_millis(60)).await;
    !user.is_empty() && !action.is_empty()
}

// 组合多个异步操作
async fn handle_request(user_id: u32) -> Result<String, String> {
    // 获取用户(必须先完成)
    let user = fetch_user(user_id).await?;

    // 并发获取配置和检查权限(互不依赖)
    let (config, has_permission) = tokio::join!(
        fetch_config("theme"),
        check_permission(&user, "read")
    );

    if !has_permission {
        return Err("权限不足".to_string());
    }

    Ok(format!("用户: {}, 配置: {}, 权限: 通过", user, config))
}

#[tokio::main]
async fn main() {
    let start = Instant::now();

    // 处理多个请求
    println!("=== 顺序处理请求 ===");
    for id in [1, 2, 3] {
        match handle_request(id).await {
            Ok(result) => println!("  请求{}: {}", id, result),
            Err(e) => println!("  请求{}: 错误 - {}", id, e),
        }
    }
    println!("顺序耗时: {:?}\n", start.elapsed());

    // 并发处理请求
    let start = Instant::now();
    println!("=== 并发处理请求 ===");
    let (r1, r2, r3) = tokio::join!(
        handle_request(1),
        handle_request(2),
        handle_request(3),
    );

    for (id, result) in [(1, r1), (2, r2), (3, r3)] {
        match result {
            Ok(msg) => println!("  请求{}: {}", id, msg),
            Err(e) => println!("  请求{}: 错误 - {}", id, e),
        }
    }
    println!("并发耗时: {:?}", start.elapsed());

    // 错误处理
    println!("\n=== 错误处理 ===");
    match handle_request(0).await {
        Ok(msg) => println!("  成功: {}", msg),
        Err(e) => println!("  失败: {}", e),
    }
}

常见问题 ​

问题一:async fn 和普通 fn 什么时候用哪个?

如果函数内部需要等待 IO 操作(网络、文件、数据库等),用 async fn。如果是纯 CPU 计算,用普通 fn。在异步代码中做 CPU 密集型工作会阻塞执行器线程,应该用 tokio::task::spawn_blocking 把计算放到专门的线程池。

问题二:为什么 async fn 是惰性的?

惰性设计让你可以先创建 Future 再决定如何执行它——顺序 await、用 join! 并发、用 select! 竞争等。如果调用就立即执行,就失去了这种灵活性。

问题三:async fn 可以递归调用吗?

直接递归不行,因为编译器无法确定 Future 的大小。需要用 Box::pin 包装:Box::pin(async move { ... }),或者使用 async_recursion crate。

问题四:main 函数可以是 async 的吗?

Rust 标准的 main 不能是 async。但通过 #[tokio::main] 或 #[async_std::main] 宏可以实现 async fn main()。这些宏本质上是在内部创建了运行时并调用 block_on。

适用场景 ​

  • IO 密集型操作:网络请求、文件读写、数据库查询
  • 并发请求:同时发起多个独立的异步操作
  • 事件驱动:响应用户输入、WebSocket 消息等
  • 服务端编程:处理大量并发连接

注意事项 ​

  • async fn 调用只创建 Future,不立即执行
  • .await 只能在 async 函数或代码块中使用
  • 需要异步运行时(如 tokio、async-std)来驱动 Future
  • 异步代码中不要使用 std::thread::sleep,用 tokio::time::sleep
  • async fn 中借用参数时,Future 存活期间引用必须有效
  • CPU 密集型任务应使用 spawn_blocking 放入线程池

总结 ​

async 关键字将函数或代码块转换为返回 Future 的状态机。async fn 的返回类型 T 实际变为 impl Future<Output = T>。调用 async fn 不会执行代码,只创建一个 Future 对象(惰性求值),必须通过 .await 或运行时的 poll 才会真正执行。async 和 .await 成对使用,async 创建 Future,.await 等待完成。多个独立的异步操作可以用 tokio::join! 并发执行。异步函数适合 IO 密集型场景,CPU 密集型任务应使用 spawn_blocking。需要异步运行时(tokio 等)来驱动 Future 的执行。