11.6 阶段 5 并发与异步
所属:全栈开发面试题库 / 学习路径 / 11 Rust 全栈
本页目录
一、阶段定位
阶段 4 解决的是「单线程内怎么安全地共享可变状态」:Rc<RefCell<T>>、内部可变性、Pin 与 Box 的所有权模型已经能写通。但只要把这些类型往 std::thread::spawn 里一塞,编译器立刻用 Send/Sync 两条 trait 把路堵死。本阶段要解决的是 Rust 并发与异步的三件硬事:
- 线程间传递的合法性由
Send/Sync决定,而不是程序员口头保证。Rc不是Send,MutexGuard跨线程会编译失败;理解自动派生规则,是看懂一切并发报错的前提。 - Rust 的并发不是「开线程就行」,而是把任务分成两条路:CPU 密集用
rayon做数据并行,IO 密集用async/await+ Tokio 做任务并发。两条路在错误信息、阻塞行为、取消语义上完全不同,混用会直接卡死执行器。 - 异步是惰性的状态机,不是「调用就执行」的协程。
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表示把Tmove 到别的线程是安全的。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 分钟内给出排查路径
自测题(先自己想,再看要点):
Send与Sync的区别是什么?为什么Rc不是Send?- 要点:
Send是所有权转移安全,Sync是共享引用安全;Rc的引用计数是普通usize,并发 clone 会数据竞争。
- 要点:
- 为什么
MutexGuard不能跨.await?怎么修?- 要点:std
MutexGuard不是Send;在 await 前把需要的数据 clone 出来,drop guard 再 await。
- 要点:std
async fn foo() -> u32 { 1 }直接写在main里为什么不执行?- 要点:它返回的是
impl Future,不被 poll 就不跑;要用#[tokio::main]或block_on。
- 要点:它返回的是
- 在 async handler 里写
std::thread::sleep(1s)会发生什么?- 要点:阻塞整个 tokio worker 线程,同 worker 上其它 future 全部停摆;应换
tokio::time::sleep或spawn_blocking。
- 要点:阻塞整个 tokio worker 线程,同 worker 上其它 future 全部停摆;应换
select!里放一个tx.send(msg).await会有什么风险?- 要点:send 不是取消安全的,被 cancel 时可能消息已写一半;应先 send 完再 select 其它分支。
Arc<Mutex<T>>与Rc<RefCell<T>>的适用场景差别?- 要点:前者跨线程运行期互斥,后者单线程运行期借用检查;前者
Send + Sync,后者都不是。
- 要点:前者跨线程运行期互斥,后者单线程运行期借用检查;前者
tokio::spawn为什么要求 future 是Send + 'static?- 要点:任务可能被调度到任意 worker 线程,所以必须能跨线程发送;任务生命周期不由调用者控制,所以不能引用栈上局部变量。