惰性求值与立即执行
核心概念
Rust 的异步模型采用惰性求值(lazy evaluation)——调用一个 async fn 或创建一个 async {} 块时不会执行任何代码,只是返回一个 Future 对象。Future 本身就是一个待执行的计算描述,只有当它被 .await、被运行时 poll、或者通过 tokio::spawn 提交到执行器时,代码才会真正运行。这和许多其他语言(如 JavaScript 的 Promise)的立即执行模型有本质区别。惰性求值带来了灵活性——你可以先创建多个 Future,然后决定是顺序执行、并发执行还是竞争执行。
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 立即执行的对比
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 |
惰性求值的优势
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
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 的任务时间执行
}基本示例
展示惰性求值在实际应用中的灵活性:
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 的关键。