罗罗编程学习记录
本页内容 展开查看

11.6 阶段 5 并发与异步

所属:全栈开发面试题库 / 学习路径 / 11 Rust 全栈

本页目录

一、阶段定位

阶段 4 解决的是「单线程内怎么安全地共享可变状态」:Rc<RefCell<T>>、内部可变性、Pin 与 Box 的所有权模型已经能写通。但只要把这些类型往 std::thread::spawn 里一塞,编译器立刻用 Send/Sync 两条 trait 把路堵死。本阶段要解决的是 Rust 并发与异步的三件硬事:

  1. 线程间传递的合法性由 Send/Sync 决定,而不是程序员口头保证。Rc 不是 Send,MutexGuard 跨线程会编译失败;理解自动派生规则,是看懂一切并发报错的前提。
  2. Rust 的并发不是「开线程就行」,而是把任务分成两条路:CPU 密集用 rayon 做数据并行,IO 密集用 async/await + Tokio 做任务并发。两条路在错误信息、阻塞行为、取消语义上完全不同,混用会直接卡死执行器。
  3. 异步是惰性的状态机,不是「调用就执行」的协程。async fn 返回的是一个 Future,不被 poll 就一行都不跑;select! 取消时哪些 future 会丢数据,是面试与线上事故的双重重灾区。

与前后阶段的衔接:往上承接阶段 4 的智能指针——Arc<Mutex<T>> 就是「跨线程版的 Rc<RefCell<T>>」,所有权模型一致,只是把运行期借用检查换成运行期互斥锁。往下接阶段 6 的工程化与阶段 7 的 axum 全链路——axum 的 handler 必须是 async fn,提取器、中间件、数据库连接池全部跑在 Tokio 上;本阶段不懂 spawn_blocking、取消安全、JoinSet,阶段 7 写出来的服务要么阻塞执行器线程被拖垮,要么在超时时丢半条数据。

「怎么判断自己卡住了」:看到 future cannot be sent between threads safely 时只会机械加 Arc 而定位不到具体是哪个字段不满足 Send;在 async fn 里写 std::thread::sleep 或同步数据库调用而不自知;用 tokio::select! 但说不清哪一个分支被取消时会丢写。出现这三种现象,说明本阶段没过,不要往下走。

二、阶段目标与投入

能力目标(可验证的行为) 验证方式
能解释 Send 与 Sync 的区别,能通过编译错误定位到具体哪个字段不满足约束 给一段跨线程代码,报 future cannot be sent between threads safely,能指出是哪个字段并修复
能用 std::thread::spawn + move 闭包 + mpsc 通道写出 N 个生产者 1 个消费者 用 cargo build 通过,运行结果正确,且能解释为什么 Rc 不能进闭包
能用 Arc<Mutex<T>> 与 Arc<RwLock<T>> 写共享状态,并说明读写锁何时优于互斥锁 写一个计数累加器,100 线程并发跑,结果正确
能用 rayon 把一个串行 iter 改造成并行 par_iter,并对比耗时 对 100 万元素求和,并行版本在多核机器上明显更快
能解释 async fn 为什么编译成状态机、Future 为什么是惰性的 写一个不被 poll 的 future,打印证明它没执行
能正确使用 Tokio 多线程运行时、spawn、spawn_blocking、tokio::time::timeout、tokio::select! 写一个「两个任务赛跑,超时 200ms 取消」的 demo,且能说清取消安全

建议学时:

  • 全职(每天 4–6 小时):2 周,约 60–70 小时。读文档 15 小时、写代码 45 小时、复盘 10 小时。
  • 在职(每天 2 小时、周末补 4 小时):5–6 周。

学时分配:Send/Sync 10%、线程与通道 15%、共享状态锁 15%、rayon 10%、Future 模型 15%、Tokio 运行时 20%、select!/取消安全/JoinSet 15%。取消安全与阻塞隔离是最容易在线上出事的两块,时间要给够。

三、先修自检

先修项 合格标准 不合格时回到
所有权与借用 能写通 &mut 与 & 共存,理解 NLL 阶段 2 所有权、借用与生命周期
trait 与泛型 知道 impl Trait、dyn Trait、trait object 的区别 阶段 3 trait 与抽象设计
智能指针 能写通 Rc<RefCell<T>>,理解 Pin 的存在意义 阶段 4 智能指针与内部可变性
Cargo 基本命令 cargo new、cargo build、cargo run、cargo add 能跑通 阶段 0 工具链与开发环境
线程与进程概念 知道 OS 线程、上下文切换、阻塞是什么 01 计算机基础与通用工程

四、知识地图

「掌握程度」分三档:了解、会用、能讲清原理。

模块 知识点 掌握程度 对应题库章节
Send/Sync 标记 trait、自动派生、手动实现的 unsafe 前提、!Send 类型 能讲清原理 04.4.2 并发与工程实践
线程与通道 thread::spawn、move、JoinHandle、mpsc、crossbeam 会用 04.4.2 并发与工程实践
共享状态 Arc、Mutex、RwLock、parking_lot 差异 能讲清原理 04.4.2 并发与工程实践
数据并行 rayon、par_iter、工作窃取、scope 会用 04.4.2 并发与工程实践
Future 模型 poll、状态机、Pin、Waker、惰性 能讲清原理 04.4.7 异步运行时与协议层
Tokio 运行时 #[tokio::main]、multi_thread/current_thread flavor、spawn、block_on 会用 04.4.7 异步运行时与协议层
阻塞隔离 spawn_blocking、为什么不能在 async 里 std::thread::sleep 能讲清原理 04.4.7 异步运行时与协议层
取消与超时 select!、取消安全、timeout、JoinSet、Semaphore 能讲清原理 04.4.7 异步运行时与协议层

进度管理建议:把 Send/Sync 与取消安全两档务必推到「能讲清原理」,其余至少「会用」。《知识点全清单》是本篇更细的全量清单。

五、分模块精讲

5.1 Send 与 Sync:跨线程合法性的两条标记 trait

为什么需要它:Rust 不要求程序员口头保证「这个变量我不会在另一个线程用」,而是用编译器在编译期拒绝一切可能数据竞争的类型传递。没有 Send/Sync,Arc 与裸指针的边界就守不住。

核心机制:

  • Send:类型的值可以被转移所有权到另一个线程。T: Send 表示把 T move 到别的线程是安全的。
  • Sync:类型的值可以被多个线程共享引用。T: Sync 等价于 &T: Send。
  • 绝大多数类型自动满足两者,规则是「字段全部 Send/Sync 则整体自动满足」。Rc<T> 不满足 Send,因为它的引用计数不是原子的;MutexGuard<'_, T> 不是 Send(但它是 Sync,只要 T: Sync),因为锁的释放必须发生在持有它的线程。
  • 手动实现 unsafe impl Send for T / unsafe impl Sync for T 是 unsafe 行为,必须由你自己证明内部同步逻辑成立(例如 crossbeam::epoch 的类型、某些 FFI 边界)。
  • 常见约束写法:async fn 返回的 future 要被 tokio::spawn,要求 Future + Send;std::thread::spawn 的闭包要求 FnOnce + Send + 'static。

最小可运行示例:

// Cargo.toml 无需额外依赖,标准库即可
use std::thread;

fn main() {
    // move 闭包把所有权搬进新线程
    let v = vec![1, 2, 3];
    let handle = thread::spawn(move || {
        println!("子线程看到 {:?}", v);
        v.len()
    });
    let n = handle.join().unwrap();
    println!("子线程返回 {}", n);

    // 下面这行会编译失败:Rc 不是 Send
    // let rc = std::rc::Rc::new(42);
    // thread::spawn(move || println!("{}", rc));
    // error: `Rc<i32>` cannot be sent between threads safely
}
# Cargo.toml
[package]
name = "send-demo"
version = "0.1.0"
edition = "2021"

常见坑:

现象 原因 修法
error[E0277]: Rc cannot be sent between threads safely 把 Rc move 进了 thread::spawn 闭包 改用 std::sync::Arc
error: future cannot be sent between threads safely tokio::spawn 的 future 内部持有了 !Send 类型(如 Rc、MutexGuard 跨 await) 把 Rc 换 Arc;不要在 .await 期间持有 MutexGuard,改为先 drop 再 await
error[E0277]: *mut i32 cannot be sent between threads safely 裸指针 *mut T 默认既非 Send 也非 Sync 包一层 unsafe impl Send 的 newtype,或改用 AtomicPtr

面试考法:必问「Send 和 Sync 的区别」「为什么 Rc 不是 Send 而 Arc 是」「为什么 MutexGuard 不能跨线程」。要答到:Send 是所有权转移安全,Sync 是共享引用安全;Rc 的计数是普通整型,并发 clone 会数据竞争,Arc 用 AtomicUsize;MutexGuard 跨线程意味着在 B 线程释放 A 线程持有的锁,这违反互斥锁的所有权模型,所以 std 把它标成 !Send。

5.2 thread::spawn、move 闭包与 mpsc 通道

为什么需要它:线程是 OS 级并发单元,通道是 Rust 标准库内建的线程间通信方式。move 闭包是把变量搬进线程的唯一合法途径;不理解它,就会写出「借用了局部变量,闭包一结束变量被释放」的悬垂引用。

核心机制:

  • thread::spawn(f) 返回 JoinHandle<T>,join() 会阻塞直到子线程结束并返回 Result<T, Box<dyn Error + Send>>。
  • move 闭包按所有权把捕获的变量 move 进闭包体;不写 move 则默认借用。
  • std::sync::mpsc:multi-producer, single-consumer。channel() 返回 (Sender<T>, Receiver<T>),Sender: Clone,Receiver 不 Clone。发送方断开后 recv() 返回 Err。
  • 与 crossbeam-channel 的语义差异:std::mpsc 的 recv 是阻塞的、关闭后行为固定;crossbeam-channel 支持 select!、多通道混合、工作窃取友好,且无 alloc 兜底。日常新代码推荐 crossbeam-channel,标准库通道用于理解模型。
  • 带缓冲通道 channel(N) 与无缓冲 sync_channel(0):后者发送会阻塞直到接收方就绪。

最小可运行示例:

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();
    // 多个生产者:tx 可以 clone
    for i in 0..4 {
        let tx = tx.clone();
        thread::spawn(move || {
            tx.send(format!("worker-{}", i)).unwrap();
        });
    }
    drop(tx); // 主线程也持有一份,drop 后接收方才能在全部断开后结束

    for received in rx {
        println!("收到 {}", received);
    }
}

常见坑:

现象 原因 修法
closure may outlive the current function, but it borrows ... 没写 move,闭包借用了局部变量 加 move,或用 Arc 共享
receiver 一直阻塞收不到结束 主线程自己持有的 tx 没 drop drop(tx),或用 crossbeam 的作用域
borrow of moved value: tx 已经把 tx move 给子线程又在主线程用 先 tx.clone() 再 move,最后 drop(tx)
发送 panic:SendError(..) 接收端已被 drop 发送端用 let _ = tx.send(..) 容错

面试考法:「mpsc 的 s 是什么意思」「无缓冲与有缓冲通道的区别」「为什么 Sender 能 Clone 而 Receiver 不能」。答到:s 是 single-consumer;无缓冲是 rendezvous;Receiver 只能有一个,否则就不是单消费者模型。

5.3 共享状态:Arc<Mutex<T>> 与 Arc<RwLock<T>>

为什么需要它:多线程共享可变数据时,通道只解决「传递所有权」,不解决「大家都持有的一份数据怎么改」。Arc<Mutex<T>> 是 Rust 跨线程共享可变状态的默认写法。

核心机制:

  • Arc<T>:原子引用计数,Clone 是原子操作;Arc::clone(&arc) 不深拷贝。
  • Mutex<T>:互斥锁,lock() 返回 LockResult<MutexGuard<'_, T>>,guard 用 Deref/DerefMut 暴露 &T/&mut T;guard 离开作用域自动释放。
  • RwLock<T>:读共享、写独占。read() 多个并发,write() 独占。读远多于写时用它;写频繁时互斥锁更快,因为 RwLock 要维护读者计数。
  • 关键陷阱:不要在 await 期间持有 MutexGuard。guard 不是 Send(std MutexGuard),跨 await 会让 future 变成 !Send,tokio::spawn 直接报错。正确做法:let data = { let g = lock.lock().unwrap(); g.clone() }; 先取出数据再 await。
  • parking_lot::Mutex/RwLock:不返回 LockResult(不会中毒),锁更轻量,lock() 直接返回 guard;线上大量项目用它替代 std。

最小可运行示例:

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0u64));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1; // guard 离开作用域自动释放
        }));
    }
    for h in handles { h.join().unwrap(); }
    println!("结果 {}", *counter.lock().unwrap()); // 10
}
# 若用 parking_lot
[dependencies]
parking_lot = "0.12"   # 当前主线版本,以官方文档为准

常见坑:

现象 原因 修法
error[E0502]: cannot borrow *num as mutable 之前其实是死锁 锁嵌套:先拿 A 再拿 B,另一线程反过来 统一加锁顺序;用 parking_lot 的 try_lock 兜底
poisoned lock: another task failed inside 持锁线程 panic 过 lock().unwrap() 或 parking_lot 直接返回 guard
future cannot be sent between threads safely 且指向 MutexGuard 在 .await 期间持有了 guard 先把需要的数据 clone() 出来,drop guard 再 await
多线程下计数器结果偏小 用了 Rc<RefCell> 而不是 Arc<Mutex> 换 Arc<Mutex<>>

面试考法:「Arc<Mutex<T>> 与 Rc<RefCell<T>> 的区别」「为什么 guard 不能跨 await」「RwLock 什么时候比 Mutex 合适」。答题要点:前者是跨线程运行期互斥,后者是单线程运行期借用检查;guard 不是 Send;读多写少用 RwLock,写多读少用 Mutex。

5.4 rayon:数据并行与工作窃取

为什么需要它:CPU 密集型任务(对 100 万元素做 map/filter/reduce)手写线程 + 同步太繁琐。rayon 把串行迭代器一行改成并行,且自动用工作窃取负载均衡。

核心机制:

  • rayon::iter::ParallelIterator 扩展了 std::iter::Iterator 的并行版:par_iter()、par_iter_mut()、into_par_iter()。
  • rayon 维护一个全局线程池(线程数等于 CPU 核数),任务被分成 chunk 偷给空闲线程。
  • 适用条件:每个元素的处理彼此独立(无共享可变状态,或已自行加锁)。
  • 组合算子:map、filter、fold、reduce、sum、collect,API 与 std 迭代器几乎一致。
  • 注意:rayon 是 CPU 并行,不要在 rayon 线程池里做阻塞 IO,会拖垮整个池。

最小可运行示例:

// Cargo.toml: rayon = "1"
use rayon::prelude::*;

fn main() {
    let v: Vec<u64> = (0..1_000_000).collect();
    // 串行
    let s1: u64 = v.iter().map(|x| x * x).sum();
    // 并行:一行替换
    let s2: u64 = v.par_iter().map(|x| x * x).sum();
    assert_eq!(s1, s2);
    println!("{}", s2);
}

常见坑:

现象 原因 修法
并行版本比串行还慢 元素太小、任务划分开销大于计算 增大 chunk 或用 with_min_len;先 profile
结果不正确 闭包里修改了外部共享可变变量 用 fold/reduce 或 Mutex/Atomic
程序卡死 在 rayon 闭包里又调用了 rayon 的阻塞 API(嵌套死锁) 用 rayon::ThreadPoolBuilder 或避免嵌套

面试考法:「rayon 的工作窃取是怎么回事」「par_iter 是不是万能加速」。答到:空闲线程从忙线程的 deque 尾部偷任务;并行加速只在 CPU 密集、任务量足够大、无共享可变状态时成立。

5.5 Future 模型与 async/await 状态机

为什么需要它:Rust 没有内置运行时,async/await 只是语法糖,编译后是一个状态机。不理解这一点,就会把 async fn 当「调用就执行的协程」,写出一堆「明明调用了却没跑」的代码。

核心机制:

  • trait Future { type Output; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>; }。
  • async fn foo() -> T 返回的是 impl Future<Output = T>,什么都还没执行。
  • 编译器把 async fn 里的 .await 之间的代码拆成多个状态,整个函数体变成一个 enum 状态机,每个状态对应一个 poll 分支。
  • Pin<&mut Self> 保证自引用结构不被移动(async 状态机里持有跨 await 的局部变量引用)。
  • 惰性:async fn 不被 poll 就一行都不跑。要跑必须 block_on(fut) 或 tokio::spawn(fut)。
  • Waker:任务未就绪时注册 waker,IO 就绪时由运行时调用 waker.wake() 再次 poll。
  • Box<dyn Future<Output = T> + Send> 是类型擦除后的 future,用于异构 future 列表(如 JoinSet 内部)。

最小可运行示例:

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

// 一个手写的 future:立刻返回 42,不依赖运行时
struct Ready42;
impl Future for Ready42 {
    type Output = u32;
    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<u32> {
        Poll::Ready(42)
    }
}

fn main() {
    // future 是惰性的:下面这行什么都不打印
    let fut = async {
        println!("这一行只有在被 poll 时才会执行");
        1
    };
    println!("future 已构造,尚未执行");
    // 要真正跑它,需要一个执行器;下面用 futures 或 tokio 的 block_on
}

常见坑:

现象 原因 修法
调用了 async fn 但内部 println 没输出 future 没被 poll 用 tokio::main 或 block_on 包裹
future is not Send because ... future 内部持有 !Send 类型跨 await 见 5.1
cannot move out of ... which is behind a Pin 手写 Future 时尝试 move self 字段 用 project 宏或 pin-project crate
嵌套 async 把栈撑爆 状态机递归过大 用 Box::pin 或 tokio::spawn 拆分

面试考法:「async fn 编译后是什么」「为什么需要 Pin」「Future 为什么是惰性的」。答题要点:状态机 enum;自引用结构不能被 move;不 poll 不执行;Waker 负责唤醒。

5.6 Tokio 运行时:#[tokio::main]、spawn、block_on

为什么需要它:Rust 标准库不提供 async 执行器,Tokio 是事实标准。运行时选错 flavor、用错 block_on,会让服务性能差一个数量级。

核心机制:

  • #[tokio::main] 是宏,展开为构造运行时 + block_on(主体)。
  • 两种 flavor:
    • #[tokio::main](默认多线程 multi_thread):多个 worker 线程,工作窃取,适合 IO 密集服务。
    • #[tokio::main(flavor = "current_thread")]:单线程,轻量,适合 CLI、测试、嵌入式。
  • tokio::spawn(fut):把 future 丢进运行时,返回 JoinHandle,要求 fut: Future + Send + 'static。
  • Runtime::new() / Runtime::block_on:手动构造运行时,用于在非 async 入口里跑一段 async。
  • std::future::pending::<()>() 用于永久挂起,std::future::ready(v) 立刻返回。

最小可运行示例:

// Cargo.toml: tokio = { version = "1", features = ["full"] }
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    // spawn 多个任务,并发执行
    let mut handles = vec![];
    for i in 0..3 {
        handles.push(tokio::spawn(async move {
            sleep(Duration::from_millis(100 * i as u64)).await;
            println!("task {} done", i);
            i
        }));
    }
    for h in handles {
        let _ = h.await;
    }
}

常见坑:

现象 原因 修法
there is no reactor running, must be called from the context of a Tokio runtime 在 #[tokio::main] 之外直接调了 tokio 的异步 API 用 Runtime::new()?.block_on(..) 包一层
主线程结束子任务没跑完 主 future 没 await JoinHandle 把所有 handle await 掉,或 tokio::join!
单线程 flavor 下吞吐上不去 用了 current_thread 跑高并发服务 改用 multi_thread
嵌套 block_on 在 async 函数里调 runtime.block_on 用 tokio::task::block_in_place 或直接 await

面试考法:「Tokio 的多线程与 current_thread flavor 区别」「spawn 为什么要求 Send + 'static」。答到:多线程跨 worker 窃取任务所以 future 必须能 Send;'static 因为任务生命周期不受调用者控制。

5.7 spawn_blocking、select! 与取消安全

为什么需要它:在 async 任务里做阻塞 IO(同步数据库调用、CPU 重计算)会卡住整个 worker 线程,所有其他任务都被拖慢。select! 是并发组合的核心,但取消时丢数据的坑只有写过线上事故才记得住。

核心机制:

  • tokio::task::spawn_blocking(f):把闭包丢到专门的阻塞线程池(默认 512 线程上限),返回 JoinHandle。用于调用同步函数、std::fs::read、同步 SQL 驱动。
  • 不要在 async 任务里写 std::thread::sleep:它会阻塞整个 worker 线程,同线程上其他 future 全部停摆。要用 tokio::time::sleep().await。
  • tokio::select!:同时 poll 多个 future,第一个 Ready 的分支执行,其余被 drop。
  • 取消安全:future 被 drop 时不能丢数据。例如 tokio::io::read 是取消安全的(读了多少就返回多少);但 mpsc::Sender::send 不是取消安全的——如果它已经把消息写了一半被 drop,消息会丢。原则:select! 里只放取消安全的 future;要发消息就先 send().await 单独做,不要放 select 里。
  • tokio::time::timeout(d, fut):超时返回 Elapsed 错误,内部就是 select!。

最小可运行示例:

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

async fn fast() -> u32 { sleep(Duration::from_millis(50)).await; 1 }
async fn slow() -> u32 { sleep(Duration::from_millis(500)).await; 2 }

#[tokio::main]
async fn main() {
    // 超时控制:slow 被取消
    match tokio::time::timeout(Duration::from_millis(200), slow).await {
        Ok(v) => println!("slow 返回 {}", v),
        Err(_) => println!("slow 超时被取消"),
    }

    // select!:fast 与 slow 赛跑,先到先得
    tokio::select! {
        v = fast() => println!("fast 先到 {}", v),
        v = slow() => println!("slow 先到 {}", v),
    }
}

常见坑:

现象 原因 修法
服务 P99 突然飙高 async handler 里调了同步 SQL 驱动或 std::thread::sleep 用 spawn_blocking 包同步调用,或换异步驱动
超时时消息发出去一半 在 select! 分支里 send().await 被取消 send 单独 await,不在 select 里做
spawn_blocking 线程数打满 阻塞任务太多 限制并发(用 Semaphore),或优化阻塞逻辑
Cannot block within async runtime 在 async 里 std::thread::sleep 换 tokio::time::sleep

面试考法:「为什么不能在 async 里用 std::thread::sleep」「什么是取消安全,举个不安全的例子」。答到:阻塞 worker 会让所有同 worker 的 future 停摆;send 跨取消点可能丢消息,要先完成再取消。

5.8 结构化并发:JoinSet、Semaphore、tracing 与 Stream

为什么需要它:tokio::spawn 是「发出去就不管」,任务泄漏、并发数失控、日志断链是三个常见事故。结构化并发让任务的生命周期由作用域管理。

核心机制:

  • tokio::task::JoinSet:收集一组任务,按完成顺序回收结果;比手动 Vec<JoinHandle> 更安全(任务 panic 不会静默丢)。
  • tokio::task::JoinHandle::abort():主动取消任务。
  • tokio::sync::Semaphore:信号量,限制并发数。Semaphore::new(N),acquire().await 拿 permit,drop 自动归还。爬虫、下游调用限流标配。
  • tokio::sync::watch、mpsc:在异步任务间传递状态。
  • tracing::span! + #[tracing::instrument]:异步任务的 span 跨 await 自动传播,tokio 特性开启后在线程池切换时也能保留上下文(tracing 的 tokio-rs/tracing 与 Tokio 的运行时配合)。
  • futures::Stream:异步迭代器,next().await 取下一项;相当于异步版 Iterator。StreamExt 提供 map/filter/take/collect。

最小可运行示例:

use tokio::sync::Semaphore;
use tokio::task::JoinSet;
use std::sync::Arc;
use std::time::Duration;

#[tokio::main]
async fn main() {
    let sem = Arc::new(Semaphore::new(2)); // 最多 2 并发
    let mut js = JoinSet::new();

    for i in 0..6 {
        let sem = sem.clone();
        js.spawn(async move {
            let _permit = sem.acquire().await.unwrap(); // 拿不到就等
            tokio::time::sleep(Duration::from_millis(100)).await;
            println!("任务 {} 完成", i);
        });
    }
    while let Some(res) = js.join_next().await {
        res.unwrap();
    }
}

常见坑:

现象 原因 修法
下游被打挂,并发数失控 没限流 用 Semaphore 包住每次调用
任务 panic 后没任何日志 用裸 tokio::spawn,没 await JoinHandle 用 JoinSet 或 spawn 后 await
日志里跨 await 后 trace_id 断了 没装 tracing 的 tokio 特性或没 Instrument::instrument #[tracing::instrument] 或 .instrument(span)
Stream 里元素顺序乱 并发 map 用了 buffer_unordered 需要顺序用 buffer_ordered

面试考法:「JoinSet 与 Vec<JoinHandle> 的区别」「怎么限制并发请求数」「Stream 与 Iterator 的区别」。答到:JoinSet 按完成顺序回收且 panic 不丢;Semaphore 限并发;Stream 是异步迭代,next() 返回 future。

六、分层练习

6.1 复现型

练习 要求 验收标准 预计耗时
Rc 跨线程报错复现 故意把 Rc::new(0) move 进 thread::spawn 编译器报 Rc<i32> cannot be sent between threads safely,能指出是引用计数非原子 0.5 小时
多生产者单消费者 4 个线程往 mpsc 发消息,主线程收齐 4 条消息全部收到,退出不阻塞 1 小时
Arc<Mutex<u64>> 累加 100 线程各加 1 结果正好 100,无数据竞争 1 小时
惰性 future 实验 构造一个打印的 async block,不 await 证明它没执行;再用 tokio::main 包起来跑通 1 小时
Tokio 超时 slow() 睡 500ms,包 200ms timeout 走 Err(Elapsed) 分支 0.5 小时

6.2 改造型

练习 要求 验收标准 预计耗时
修阻塞 worker 给定在 async handler 里 std::thread::sleep(1s) 的代码 改成 tokio::time::sleep,P99 恢复正常 1 小时
修 MutexGuard 跨 await 给定在 .await 前持有 guard 的代码,报 future cannot be sent 改成先 clone 数据、drop guard 再 await 1.5 小时
串行改并行 对 100 万元素做 map+x 后 sum,用 rayon 并行版本明显快,结果与串行一致 1.5 小时
加并发限制 给定一个无限制发 HTTP 的循环 用 Semaphore::new(10) 包下游调用 2 小时
取消安全修复 给定在 select! 里 send().await 的代码 改成先独立 send,再 select 其它分支 2 小时

6.3 设计型

练习 要求 验收标准 预计耗时
并发抓取器 给定 URL 列表,用 reqwest + Semaphore 限并发抓取 20 并发、总超时 30s、失败重试 2 次、结果写文件 5 小时
任务生命周期管理 用 JoinSet 实现「启动 N 个 worker,任一失败则取消全部」 失败时其他任务被 abort,主任务退出码非 0 4 小时
异步日志聚合 多个 channel 用 select! 合并到一个流 乱序到达的日志按时间戳排序输出 4 小时
CPU+IO 混合服务 一个服务既做 HTTP IO 又做图片缩放 CPU 缩放走 spawn_blocking,IO 走 async;压测 P99 稳定 6 小时

七、排障表

现象 可能原因 排查步骤 解决办法
future cannot be sent between threads safely future 内部持有 !Send 类型(Rc、MutexGuard、*mut T) 看错误里指向的具体字段;检查 .await 之间持有的变量 把 Rc 换 Arc;guard 跨 await 改为先取数据
there is no reactor running 在 tokio 运行时之外调了异步 API 检查是否在 main 里没用 #[tokio::main] 用 Runtime::new()?.block_on(..)
async 任务里 P99 飙高 阻塞了 worker 线程(同步调用/std::thread::sleep) 在 handler 里打点;看线程数 spawn_blocking 包同步调用;换异步驱动
poisoned lock 持锁线程 panic 看 panic 栈 用 parking_lot 或 lock().unwrap_or_else(|e| e.into_inner())
select! 超时后消息丢失 send 在 select 分支里被取消 检查 send 位置 send 单独 await,不在 select 里
并发数打满下游 没限流 看下游 QPS 曲线 Semaphore 限制并发
borrow of moved value 出现在闭包 move 闭包把变量搬走了,后面又用 看错误行 先 clone() 再 move;或 Arc::clone
JoinSet 里任务 panic 被吞 没处理 JoinError 检查 while let Some(res) = js.join_next().await res.unwrap() 或记录错误

八、出口条件

全部勾选后再进入 阶段 6 Cargo 工程化与质量体系。

  • [ ] 能看懂 future cannot be sent between threads safely 报错,并定位到具体不满足 Send 的字段
  • [ ] 能写通 thread::spawn + move + mpsc 多生产者单消费者,且不挂死
  • [ ] 能用 Arc<Mutex<T>> 写 100 线程累加器,结果正确
  • [ ] 能解释 async fn 为什么编译成状态机、为什么不 poll 不执行
  • [ ] 能正确区分 std::thread::sleep 与 tokio::time::sleep,并用 spawn_blocking 包同步调用
  • [ ] 能说清 select! 的取消安全,并举一个不安全的例子
  • [ ] 能用 Semaphore 限制并发、用 JoinSet 管理任务生命周期
  • [ ] 排障表里随机抽三个现象,能在 5 分钟内给出排查路径

自测题(先自己想,再看要点):

  1. Send 与 Sync 的区别是什么?为什么 Rc 不是 Send?
    • 要点:Send 是所有权转移安全,Sync 是共享引用安全;Rc 的引用计数是普通 usize,并发 clone 会数据竞争。
  2. 为什么 MutexGuard 不能跨 .await?怎么修?
    • 要点:std MutexGuard 不是 Send;在 await 前把需要的数据 clone 出来,drop guard 再 await。
  3. async fn foo() -> u32 { 1 } 直接写在 main 里为什么不执行?
    • 要点:它返回的是 impl Future,不被 poll 就不跑;要用 #[tokio::main] 或 block_on。
  4. 在 async handler 里写 std::thread::sleep(1s) 会发生什么?
    • 要点:阻塞整个 tokio worker 线程,同 worker 上其它 future 全部停摆;应换 tokio::time::sleep 或 spawn_blocking。
  5. select! 里放一个 tx.send(msg).await 会有什么风险?
    • 要点:send 不是取消安全的,被 cancel 时可能消息已写一半;应先 send 完再 select 其它分支。
  6. Arc<Mutex<T>> 与 Rc<RefCell<T>> 的适用场景差别?
    • 要点:前者跨线程运行期互斥,后者单线程运行期借用检查;前者 Send + Sync,后者都不是。
  7. tokio::spawn 为什么要求 future 是 Send + 'static?
    • 要点:任务可能被调度到任意 worker 线程,所以必须能跨线程发送;任务生命周期不由调用者控制,所以不能引用栈上局部变量。