Rust异步编程实战：彻底搞懂并发、并行与Tokio任务调度

随着多核时代的到来，如何高效利用系统资源成为现代编程的关键挑战。在 Rust 语言中，异步编程（Async Rust）凭借其零成本抽象和卓越的性能，成为了构建高并发系统的首选方案。然而，初学者常常混淆“并发”与“并行”，也不清楚强大的 Tokio 运行时是如何调度和管理任务的。本文将从底层定义出发，通过厨房做饭的生动类比，并结合具体的 Rust 代码示例和运行结果分析，彻底解析异步 Rust 中的并发、并行以及 tokio::join!、JoinSet 等核心机制，带您领略高效任务调度的奥秘。

Async Rust - 并发 VS 并行

并发 VS 并行 Concurrency vs Parallelism Async Rust

并发 VS 并行

🧩 一、定义对比

📖 简单说：

并发是「看起来同时」， 并行是「真的同时」。

🧠 二、类比理解

想象你在厨房做饭 🍳：

• 并发：你一个人炒菜、煮汤、蒸饭。你在三个任务之间来回切换。虽然是一个人，但三个任务“看起来”在同时进行。
• 并行：你和朋友三个人，各自负责炒菜、煮汤、蒸饭，真的在同时进行。

👉 所以：

并发 = 切换快，看起来同时。 并行 = 多人多核，真正同时。

⚙️ 三、技术层面区别

💻 四、例子说明

1️⃣ 并发（单核异步）

import asyncio

async def task(name, delay):
    await asyncio.sleep(delay)
    print(f"{name} done")

async def main():
    await asyncio.gather(
        task("A", 2),
        task("B", 1),
        task("C", 3)
    )

asyncio.run(main())

🔹 实际上是单核运行，通过 协程切换 实现“同时”执行的效果。 🔹 这就是并发：交替执行。

2️⃣ 并行（多核线程）

from multiprocessing import Pool
import time

def task(n):
    time.sleep(2)
    return n*n

if __name__ == "__main__":
    with Pool(4) as p:
        results = p.map(task, [1,2,3,4])
    print(results)

🔹 使用 4 个 CPU 核同时执行任务。 🔹 这是真正的 并行：物理同时执行。

🔗 五、并发与并行的关系

并行 ⊂ 并发

也就是说：

• 并发是一种设计思想；
• 并行是一种执行方式；
• 有并发，不一定有并行；
• 但有并行，必然也是并发的一种表现。

📊 形象图：

          并发 (Concurrency)
        ┌──────────────────────┐
        │                      │
        │   并行 (Parallelism) │
        │     ← 子集关系       │
        └──────────────────────┘

🚀 六、总结一句话记忆法

异步挂起/恢复

Async Suspend/Resume

异步挂起/恢复（Async Suspend/Resume）是指在异步执行中，当任务遇到无法立即完成的操作时暂停执行（挂起），待条件满足后再从暂停点继续执行（恢复），以实现高效的并发处理。

系统线程 VS 绿色线程 Async Rust

OS Threads VS Green Threads

示例一

async fn hello() {
    println!("Hello, world!");
}

async fn run() {
    for i in 0..10 {
        println!("{i}");
    }
}

#[tokio::main]
async fn main() {
    tokio::spawn(run());
    hello().await;
}

这段 Rust 代码展示了异步编程的基本用法，使用了流行的异步运行时 Tokio。

详细解释：

1. async fn hello() 和 async fn run():
   • async fn 关键字定义了异步函数。调用这些函数并不会立即执行它们里面的代码，而是返回一个表示异步操作的Future（一个尚未完成的计算）。
   • hello 函数非常简单，它会打印一次 "Hello, world!"。
   • run 函数会执行一个简单的循环，打印数字 $0$ 到 $9$。
2. #[tokio::main]:
   • 这是一个 Tokio 提供的宏，用于标记程序的入口点 main 函数。
   • 它将 async fn main() 转换为一个同步的 main 函数，这个同步 main 函数负责初始化 Tokio 异步运行时（Runtime），然后在这个运行时上执行异步的 main 函数体。
   • 异步运行时是执行和调度异步任务（Future）的核心组件。
3. async fn main():
   • 这是程序的逻辑起点。
   • tokio::spawn(run());:
     • tokio::spawn() 是 Tokio 运行时提供的方法，用于在异步运行时上启动一个新的异步任务（一个 Future）。
     • 这里它接收 run() 返回的 Future，并将其非阻塞地调度到后台运行。这意味着 run 函数中的循环将与主任务（main 函数的其余部分）并发执行。
     • tokio::spawn() 立即返回一个JoinHandle，但代码中没有接收或使用它。
   • hello().await;:
     • hello() 调用返回一个 Future。
     • .await 运算符用于暂停当前异步任务（这里是 main 函数）的执行，等待它所修饰的 Future（hello() 的结果）完成。
     • 当 hello() 完成（即打印出 "Hello, world!"）后，main 函数才会继续执行。
     • 注意: await 只在 async 函数/块内使用。

总结执行流程：

1. 程序启动，#[tokio::main] 宏初始化 Tokio 运行时并开始执行 async main。
2. tokio::spawn(run());：run 任务（打印 $0-9$）被提交给运行时，开始在后台并发执行。
3. hello().await;：main 任务暂停，等待 hello 函数执行完毕（打印 "Hello, world!"）。
4. 在 main 任务等待时，Tokio 运行时可以切换到执行其他任务，例如并发运行的 run 任务。
5. hello 任务执行完毕后，main 任务恢复，程序结束。

由于 run 是并发执行的，因此 run 中打印的数字 $0-9$ 和 hello 中打印的 "Hello, world!" 在控制台的出现顺序是不确定的，取决于 Tokio 运行时对这两个任务的调度情况。run 任务可能会在 "Hello, world!" 之前、之后或中间穿插打印。

运行

➜ cargo run              
   Compiling scopeguard v1.2.0
   Compiling smallvec v1.15.1
   Compiling cfg-if v1.0.4
   Compiling bytes v1.10.1
   Compiling pin-project-lite v0.2.16
   Compiling libc v0.2.177
   Compiling lock_api v0.4.14
   Compiling parking_lot_core v0.9.12
   Compiling mio v1.1.0
   Compiling signal-hook-registry v1.4.6
   Compiling socket2 v0.6.1
   Compiling parking_lot v0.12.5
   Compiling tokio v1.48.0
   Compiling rust_os_threads v0.1.0 (/Users/qiaopengjun/Code/Rust/RustJourney/rust_os_threads)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 3.17s
     Running `target/debug/rust_os_threads`
Hello, world!
0
1
2
3
4
5
6
7
8
9

💻 运行结果解释

1. 编译阶段 (Compiling & Finished)

这是 Rust 的构建工具 cargo 执行 cargo run 命令时首先完成的工作：

• Compiling ...: 这一系列行表示 Cargo 正在编译项目及其依赖项。由于您的代码使用了 #[tokio::main]，它依赖于 Tokio 运行时，因此 Cargo 会编译如 tokio、mio、bytes 等一系列相关的异步和低级系统库。
• Compiling rust_os_threads v0.1.0 (...): 这是在编译您的本地项目（项目名称为 rust_os_threads）。
• Finished ... target(s) in 3.17s: 表示编译过程成功完成，生成了调试版本 (dev profile) 的可执行文件。

2. 运行阶段 (Running & Output)

编译成功后，Cargo 接着执行生成的可执行文件：

• Running target/debug/rust_os_threads: Cargo 启动了编译好的程序。
• Hello, world!: 这是由您的 hello() 异步函数打印的输出。在 main 函数中，hello().await; 会确保这个任务完成。
• 0 到 9: 这是由您的 run() 异步函数打印的输出。在 main 函数中，tokio::spawn(run()); 将此任务并发地调度到后台。

关键点在于输出的顺序：

程序首先等待 hello().await 完成，因此 Hello, world! 被打印出来。然后，由于 run 任务是并发运行的，Tokio 运行时在执行 hello 和等待其完成的过程中，也同时调度了 run 任务。在这个特定的运行实例中，run 任务在 hello 任务完成后才开始或继续执行，所以打印 $0$ 到 $9$ 的循环是在 Hello, world! 之后连续完成的。如果调度顺序不同，0-9 的输出可能会出现在 Hello, world! 之前或中间。