惰性求值与立即执行 ​

核心概念 ​

Rust 的异步模型采用惰性求值(lazy evaluation)——调用一个 async fn 或创建一个 async {} 块时不会执行任何代码,只是返回一个 Future 对象。Future 本身就是一个待执行的计算描述,只有当它被 .await、被运行时 poll、或者通过 tokio::spawn 提交到执行器时,代码才会真正运行。这和许多其他语言(如 JavaScript 的 Promise)的立即执行模型有本质区别。惰性求值带来了灵活性——你可以先创建多个 Future,然后决定是顺序执行、并发执行还是竞争执行。

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

async fn work(name: &str) -> String {
    println!("  {} 开始执行", name);
    sleep(Duration::from_millis(100)).await;
    println!("  {} 执行完成", name);
    format!("{}的结果", name)
}

#[tokio::main]
async fn main() {
    // 调用 async fn 不会执行任何代码
    println!("创建 Future...");
    let future_a = work("任务A");
    let future_b = work("任务B");
    println!("两个 Future 已创建,但没有任何输出\n");

    // .await 才真正执行
    println!("开始 await:");
    let result_a = future_a.await;
    let result_b = future_b.await;
    println!("结果: {}, {}", result_a, result_b);
}

惰性 vs 立即执行的对比 ​

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

async fn lazy_task(id: u32) -> u32 {
    println!("    任务{} 运行中", id);
    sleep(Duration::from_millis(100)).await;
    id * 10
}

#[tokio::main]
async fn main() {
    // === Rust Future 是惰性的 ===
    println!("=== 惰性求值 ===");
    let f1 = lazy_task(1);  // 不执行
    let f2 = lazy_task(2);  // 不执行
    let f3 = lazy_task(3);  // 不执行
    println!("  三个 Future 已创建(无输出)");
    println!("  现在开始 await:");
    let r1 = f1.await;  // 此时才执行任务1
    let r2 = f2.await;  // 此时才执行任务2
    let r3 = f3.await;  // 此时才执行任务3
    println!("  结果: {}, {}, {}\n", r1, r2, r3);

    // === tokio::spawn 是立即提交执行的 ===
    println!("=== spawn 立即提交 ===");
    let start = Instant::now();

    // spawn 把任务提交给执行器,立刻开始调度
    let h1 = tokio::spawn(lazy_task(1));
    let h2 = tokio::spawn(lazy_task(2));
    let h3 = tokio::spawn(lazy_task(3));
    println!("  三个任务已 spawn(可能已开始执行)");

    // await JoinHandle 等待完成
    let r1 = h1.await.unwrap();
    let r2 = h2.await.unwrap();
    let r3 = h3.await.unwrap();
    println!("  结果: {}, {}, {}", r1, r2, r3);
    println!("  耗时: {:?}(并发执行)", start.elapsed());
}
特性惰性 Future(async fn 调用)立即执行(tokio::spawn)
创建时不执行立即提交给执行器
执行时机.await 或被 poll创建后由执行器调度
执行线程当前任务的线程执行器分配的线程
取消不 await 就不执行需要显式 abort
错误传播直接通过 .await通过 JoinHandle

惰性求值的优势 ​

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

async fn expensive_query(name: &str) -> String {
    println!("    执行查询: {}", name);
    sleep(Duration::from_millis(150)).await;
    format!("{}的数据", name)
}

#[tokio::main]
async fn main() {
    // === 优势1:可以选择执行策略 ===
    println!("=== 选择执行策略 ===");

    // 同样的 Future,不同的执行方式
    let start = Instant::now();

    // 顺序执行
    let r1 = expensive_query("用户表").await;
    let r2 = expensive_query("订单表").await;
    println!("  顺序: {}, {} ({:?})\n", r1, r2, start.elapsed());

    let start = Instant::now();

    // 并发执行(用 join!)
    let (r1, r2) = tokio::join!(
        expensive_query("用户表"),
        expensive_query("订单表"),
    );
    println!("  并发: {}, {} ({:?})\n", r1, r2, start.elapsed());

    // === 优势2:条件性执行 ===
    println!("=== 条件性执行 ===");
    let need_data = false;

    // 创建 Future 没有开销
    let future = expensive_query("大数据表");

    if need_data {
        let data = future.await;
        println!("  数据: {}", data);
    } else {
        println!("  不需要数据,跳过查询(没有任何 IO 发生)");
        // future 被 drop,查询从未执行
    }

    // === 优势3:超时和取消 ===
    println!("\n=== 超时控制 ===");
    let future = expensive_query("慢速查询");

    match tokio::time::timeout(Duration::from_millis(50), future).await {
        Ok(data) => println!("  成功: {}", data),
        Err(_) => println!("  超时,查询被取消(不会继续执行)"),
    }

    // === 优势4:组合和变换 ===
    println!("\n=== 动态组合 ===");
    let queries = vec!["表A", "表B", "表C"];

    // 创建 Future 集合
    let futures: Vec<_> = queries.iter()
        .map(|&name| expensive_query(name))
        .collect();

    // 一次性并发执行所有
    let results = futures::future::join_all(futures).await;
    for r in &results {
        println!("  {}", r);
    }
}

未 await 的 Future ​

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

async fn side_effect(msg: &str) {
    println!("  副作用: {}", msg);
    sleep(Duration::from_millis(50)).await;
}

#[tokio::main]
async fn main() {
    // 创建但不 await → 代码不执行,副作用不发生
    let _future = side_effect("这不会打印");
    println!("Future 创建了但没 await → 没有输出");

    // 编译器会警告未使用的 Future
    // warning: unused implementor of `Future` that must be used
    // 这是一个重要的提示,通常意味着代码有 bug

    // 正确做法:
    side_effect("这会打印").await;

    // 如果故意不执行,可以显式 drop
    let future = side_effect("故意不执行");
    drop(future);  // 明确表示不需要执行
    println!("显式 drop 了 Future");

    // spawn 的任务则会执行(即使不 await JoinHandle)
    let _handle = tokio::spawn(async {
        println!("  spawn 的任务会执行(即使不 await handle)");
    });
    sleep(Duration::from_millis(100)).await;  // 给 spawn 的任务时间执行
}

基本示例 ​

展示惰性求值在实际应用中的灵活性:

rust
use tokio::time::{sleep, Duration, Instant};
use std::future::Future;
use std::pin::Pin;

// 模拟不同数据源
async fn query_primary_db(key: &str) -> Result<String, String> {
    sleep(Duration::from_millis(200)).await;
    if key == "missing" {
        Err("主库未找到".to_string())
    } else {
        Ok(format!("主库: {}", key))
    }
}

async fn query_cache(key: &str) -> Result<String, String> {
    sleep(Duration::from_millis(30)).await;
    if key.starts_with("cached_") {
        Ok(format!("缓存: {}", key))
    } else {
        Err("缓存未命中".to_string())
    }
}

async fn query_backup_db(key: &str) -> Result<String, String> {
    sleep(Duration::from_millis(150)).await;
    Ok(format!("备份库: {}", key))
}

// 利用惰性求值实现回退策略
async fn fetch_with_fallback(key: &str) -> String {
    // 先尝试缓存(惰性:只有这一步执行)
    if let Ok(val) = query_cache(key).await {
        return val;
    }

    // 缓存未命中,并发查主库和备份库
    // 这些 Future 在这里才被创建和执行
    tokio::select! {
        Ok(val) = query_primary_db(key) => val,
        Ok(val) = query_backup_db(key) => val,
        else => "所有数据源都失败".to_string(),
    }
}

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

    // 缓存命中:只查缓存,不触发数据库查询
    println!("=== 缓存命中 ===");
    let result = fetch_with_fallback("cached_user1").await;
    println!("  结果: {} ({:?})", result, start.elapsed());

    // 缓存未命中:查缓存后并发查两个数据库
    let start = Instant::now();
    println!("\n=== 缓存未命中 ===");
    let result = fetch_with_fallback("user2").await;
    println!("  结果: {} ({:?})", result, start.elapsed());

    // 批量查询的惰性特性
    println!("\n=== 批量查询 ===");
    let start = Instant::now();
    let keys = vec!["cached_a", "b", "cached_c", "d", "e"];

    // 创建所有 Future(不执行)
    let futures: Vec<_> = keys.iter()
        .map(|&key| fetch_with_fallback(key))
        .collect();

    // 一次性并发执行
    let results = futures::future::join_all(futures).await;
    for (key, result) in keys.iter().zip(results.iter()) {
        println!("  {}: {}", key, result);
    }
    println!("  总耗时: {:?}", start.elapsed());

    // 惰性求值 + select 实现竞争
    println!("\n=== 竞争模式 ===");
    let start = Instant::now();
    let result = tokio::select! {
        val = fetch_with_fallback("cached_fast") => format!("路径A: {}", val),
        val = fetch_with_fallback("slow_key") => format!("路径B: {}", val),
    };
    println!("  最先完成: {} ({:?})", result, start.elapsed());
}

常见问题 ​

问题一:为什么 Rust 选择惰性而不是立即执行?

惰性求值让编译器能将 Future 编译为零成本的状态机,不需要立即分配任务到执行器。同时给了开发者选择执行策略的灵活性——同一个 Future 可以顺序、并发或竞争执行。

问题二:忘记 await 会怎样?

Future 不会执行,副作用不会发生。编译器会发出警告(unused Future)。这是一个常见的 bug 来源,应该认真对待编译器的警告。

问题三:tokio::spawn 和直接 await 有什么区别?

tokio::spawn 立即将任务提交给执行器,任务在后台运行,返回 JoinHandle。直接 .await 是在当前任务中顺序执行。spawn 适合不阻塞当前任务的后台工作,.await 适合需要结果才能继续的场景。

问题四:JavaScript 的 Promise 和 Rust 的 Future 有什么区别?

JavaScript 的 Promise 创建后立即开始执行(eager),Rust 的 Future 创建后不执行(lazy)。JavaScript 用回调链(.then()),Rust 用 async/await。Rust 的惰性模型更适合系统编程,可以实现零成本抽象。

适用场景 ​

  • 条件执行:根据运行时条件决定是否执行异步操作
  • 执行策略选择:先创建 Future 再决定顺序、并发或竞争
  • 超时和取消:配合 timeout 或 select! 取消未完成的操作
  • 批量操作:收集多个 Future 后统一并发执行

注意事项 ​

  • async fn 调用和 async {} 创建的 Future 是惰性的
  • 不 .await 的 Future 不会执行,注意编译器的警告
  • tokio::spawn 是立即提交执行的,不是惰性的
  • 惰性求值意味着可以灵活选择执行策略
  • 未 await 的 Future 被 drop 时不会执行
  • 副作用依赖 .await,忘记 await 会导致逻辑 bug

总结 ​

Rust 的异步模型是惰性的:调用 async fn 或创建 async {} 只返回一个 Future 对象,代码不会执行。只有 .await、被运行时 poll 或通过 tokio::spawn 提交后才会执行。这和 JavaScript Promise 的立即执行模型不同。惰性求值带来了灵活性——先创建 Future,再选择顺序执行(.await)、并发执行(join!)或竞争执行(select!)。未 await 的 Future 不会产生任何副作用,编译器会发出警告。tokio::spawn 是立即提交的例外——任务创建后即由执行器调度。理解惰性特性是避免"忘记 await"这类常见 bug 的关键。