并发编程
Rust 有个响亮的口号——"Fearless Concurrency"(无所畏惧的并发)。这不是营销词——它的意思是并发中最容易犯的错(数据竞争、迭代器失效、死锁)大部分在编译期就被拦下来。
这一章讲清楚 Rust 的并发编程——线程、消息传递、共享状态、Send/Sync。
1. 线程:thread::spawn
基本用法:
use std::thread;
let handle = thread::spawn(|| {
for i in 1..10 {
println!("hello from spawned thread {}", i);
}
});
for i in 1..5 {
println!("hello from main thread {}", i);
}
handle.join().unwrap(); // 等 spawned thread 结束
几个特点:
thread::spawn接受一个闭包——闭包会在新线程里跑;- 返回
JoinHandle——用.join()等它结束; - 主线程结束时,所有其他线程也结束(除非它们已经 join 过)。
2. move 闭包:跨线程传数据
闭包在别的线程里跑,捕获的变量必须"跟着走":
let v = vec![1, 2, 3];
let handle = thread::spawn(|| {
println!("{:?}", v); // 错!编译器不确定 v 能活多久
});
修复:加 move:
let v = vec![1, 2, 3];
let handle = thread::spawn(move || {
println!("{:?}", v); // v 被 move 到新线程
});
// println!("{:?}", v); // 错,v 已经被 move
规则:跨线程传数据几乎必须用 move 闭包——编译期保证数据只在一个线程里。
3. 消息传递:Channel
消息传递是并发编程里最经典的模型——"不要通过共享内存来通信,而是通过通信来共享内存"(Go 语言的箴言,Rust 也支持):
use std::sync::mpsc; // multi-producer, single-consumer
use std::thread;
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
tx.send(String::from("hello")).unwrap();
});
let received = rx.recv().unwrap();
println!("got: {}", received);
注意:
mpsc:多生产者、单消费者——多个 tx 可以 clone,rx 只有一个;tx.send(v):转移所有权——发送方失去 v;rx.recv():阻塞直到有消息或者所有 tx 都 drop;rx.try_recv():非阻塞——没消息就立刻返回 Err。
多个发送者:
let (tx, rx) = mpsc::channel();
for i in 0..5 {
let tx = tx.clone();
thread::spawn(move || {
tx.send(i).unwrap();
});
}
drop(tx); // 关闭原 tx(否则 rx 一直等)
for received in rx { // 迭代直到所有 tx 关闭
println!("got: {}", received);
}
遍历接收器:for received in rx 自动接收所有消息,直到所有 tx 关闭。
4. 共享状态:Arc<Mutex<T>>
上一章讲过。回顾一下最常见的模式:
use std::sync::{Arc, Mutex};
use std::thread;
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let counter = Arc::clone(&counter);
let h = thread::spawn(move || {
let mut num = counter.lock().unwrap();
*num += 1;
// Mutex 在离开作用域时自动解锁
});
handles.push(h);
}
for h in handles { h.join().unwrap(); }
println!("Result: {}", *counter.lock().unwrap()); // 10
关键点:
Arc让多个线程能共同拥有 Mutex(Rc 不行,跨不了线程);Mutex::lock()返回一个MutexGuard——它是"锁的持有证明";- MutexGuard 离开作用域时自动解锁——不会忘 unlock;
- 如果一个线程持有锁时 panic,锁会"中毒"——其他线程再 lock 会失败(这是防止看到"半损坏状态")。
5. Send 和 Sync:编译期的并发安全
Rust 编译期就能拦下大部分并发 bug——靠 Send 和 Sync 两个 marker trait:
Send:类型可以在线程间"转移所有权"——大部分类型都是 Send。
Sync:类型可以在多个线程间"共享引用"——T 是 Sync ⟺ &T 是 Send。
这两个 trait 是 auto trait——编译器根据字段自动推导。你不用手写。
哪些不是 Send:
Rc<T>:引用计数是非原子的——两个线程同时 clone 会 race。跨线程要用 Arc。RefCell<T>:借用检查是运行时的、非原子——跨线程要用 Mutex/RwLock。
哪些不是 Sync:
Cell<T>/RefCell<T>:内部可变但不加锁。- 裸指针
*mut T:不受任何检查。
编译器怎么用这些:thread::spawn 的参数要求 Send + 'static——编译期就检查你传的东西能不能跨线程:
let rc = Rc::new(5);
thread::spawn(move || {
println!("{}", rc); // 错!Rc 不是 Send
});
这就是 Rust "fearless concurrency" 的核心——编译期就防止 data race。
6. Deadlock:编译器管不了
Send/Sync 防的是 data race——但死锁 Rust 编译期无法防。你还是要自己小心:
let a = Arc::new(Mutex::new(0));
let b = Arc::new(Mutex::new(0));
// 线程 1:先锁 a,再锁 b
let a1 = Arc::clone(&a);
let b1 = Arc::clone(&b);
let t1 = thread::spawn(move || {
let _l1 = a1.lock().unwrap();
thread::sleep(std::time::Duration::from_millis(10));
let _l2 = b1.lock().unwrap();
});
// 线程 2:先锁 b,再锁 a — 死锁!
let a2 = Arc::clone(&a);
let b2 = Arc::clone(&b);
let t2 = thread::spawn(move || {
let _l1 = b2.lock().unwrap();
thread::sleep(std::time::Duration::from_millis(10));
let _l2 = a2.lock().unwrap();
});
避免死锁的经典规则:
- 所有线程按相同顺序获取锁;
- 锁的粒度尽量小——lock 后立刻做完事就释放;
- 别在持锁时做长时间操作(尤其别 sleep、别 IO);
- 别在持锁时调用其他会 lock 的函数——容易嵌套死锁。
避免嵌套锁:能用一个 lock 就用一个——减少复杂度。
7. RwLock:读写锁
Mutex 是"互斥"——任何时候只有一个持有者。但很多场景读多写少——多个读者应该能同时读:
use std::sync::{Arc, RwLock};
let data = Arc::new(RwLock::new(vec![1, 2, 3]));
// 读:可以多个并发
let data_r = Arc::clone(&data);
thread::spawn(move || {
let reader = data_r.read().unwrap();
println!("{:?}", *reader);
});
// 写:独占
let data_w = Arc::clone(&data);
thread::spawn(move || {
let mut writer = data_w.write().unwrap();
writer.push(4);
});
规则:
- 多个
read()可以同时持有; - 只有一个
write()独占; - 有
write()时任何read()也不行。
适用场景:读远多于写。读写差不多时用普通 Mutex——RwLock 有额外开销。
8. atomics:无锁并发原语
对于简单的整数、指针操作,不需要 Mutex——用原子操作:
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;
let counter = Arc::new(AtomicUsize::new(0));
let mut handles = vec![];
for _ in 0..10 {
let counter = Arc::clone(&counter);
let h = thread::spawn(move || {
counter.fetch_add(1, Ordering::SeqCst);
});
handles.push(h);
}
for h in handles { h.join().unwrap(); }
println!("Result: {}", counter.load(Ordering::SeqCst));
Rust 提供的原子类型:
AtomicBool、AtomicUsize、AtomicIsize、AtomicPtr<T>;- 各种整数类型:
AtomicU8/U16/U32/U64/I8/I16/I32/I64。
常用操作:
.load(order):读;.store(val, order):写;.fetch_add(n, order):原子加,返回旧值;.compare_exchange(old, new, ...):CAS。
Ordering(内存排序):
Relaxed:最弱——只保证原子性,不保证顺序;Acquire/Release:中等——用于同步;SeqCst:最强——顺序一致;- 不确定选哪个用 SeqCst——性能可能差一点点,但正确性最容易保证。
原子操作是构建 lock-free 数据结构的基础——比 Mutex 快,但正确性极难保证。通用建议:能用 Mutex 就用 Mutex,性能瓶颈时再考虑 atomics。
9. 线程池:不要手动 spawn 一万个线程
每个线程有几十 KB 的栈——创建 10000 个线程会消耗几百 MB 内存。而且线程创建/销毁开销大——短任务不该开新线程。
用线程池:
rayon:数据并行的经典库:
use rayon::prelude::*;
let v: Vec<i32> = (0..1_000_000).collect();
let sum: i64 = v.par_iter().map(|&x| x as i64).sum();
par_iter 让迭代器并行——rayon 自动管理线程池,你不用操心。
crossbeam:更底层的并发原语(channels、scoped threads、原子操作等)。
tokio:异步 runtime——大部分场景不需要显式管理线程池。下一章讲。
规则:日常写并发几乎不用 thread::spawn——用 rayon 或 tokio。手写线程只在做底层库或者非常特殊的场景。
10. Scoped Threads:借用局部变量的线程
普通 thread::spawn 要求 'static——不能借用局部变量:
let v = vec![1, 2, 3];
thread::spawn(|| {
println!("{:?}", v); // 错,v 不 'static
});
用 move 也行,但要转移所有权——如果多线程都想访问 v 呢?
std::thread::scope(Rust 1.63+):scoped threads——线程在 scope 结束时必定 join,可以借用局部变量:
let v = vec![1, 2, 3];
std::thread::scope(|s| {
s.spawn(|| {
println!("thread 1: {:?}", v); // 可以借用
});
s.spawn(|| {
println!("thread 2: {:?}", v);
});
}); // scope 结束前所有线程必须 join
这个特性 crossbeam 早就有,标准库最近才加入。局部借用 + 多线程的场景 scoped threads 是最佳选择。
11. 一个典型例子:工作队列
多个 worker 从队列取任务并行处理:
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel::<i32>();
let rx = std::sync::Arc::new(std::sync::Mutex::new(rx));
// 4 个 worker
let mut workers = vec![];
for id in 0..4 {
let rx = std::sync::Arc::clone(&rx);
let w = thread::spawn(move || {
loop {
let job = rx.lock().unwrap().recv();
match job {
Ok(n) => println!("worker {} processing {}", id, n),
Err(_) => break,
}
}
});
workers.push(w);
}
// 派发任务
for i in 0..20 {
tx.send(i).unwrap();
}
drop(tx); // 关 闭 channel,所有 worker 会退出
for w in workers { w.join().unwrap(); }
}
注意 rx 用 Arc<Mutex<...>>——mpsc 的 rx 不是 Send + Sync,多线程访问要包一层。tokio 有更好的多消费者 channel(下一章讲)。