前一篇把日志工具按模块拆开了,但它仍然是一条线跑到底:读文件、统计、打印,前一步不做完后一步等着。真实场景里,日志可能有几十万行、几十个文件,单线程扫一遍要好几秒。于是很自然会想「开几个线程一起处理」。
在别的语言里,开线程就是 new Thread(...),然后把共享变量丢进去。Rust 不这么干。编译器会在你开线程的那一刻追问三个问题:这份数据归谁所有?它能不能安全地跨线程移动?多个线程同时改它时谁负责加锁?这三个问题答不上来,代码就编译不过。听起来烦,但它们恰好是并发事故的全部来源:悬垂引用、数据竞争、忘记加锁。
这篇用「多线程统计日志」这个真实需求,把 thread::spawn、move、mpsc channel、Arc<Mutex> 和 thread::scope 串一遍,并把编译器拦你时给的真实报错贴出来。示例在 Rust 2021 edition、当前 stable 下实际编译运行过。
场景走查:把统计分给几个线程
需求:一批日志行,统计 WARN 出现了多少次。为了演示,把日志切成每 4 行一段,每段交给一个线程数,主线程通过 channel 收结果汇总;再用一个共享计数器统计「有多少个线程完成了任务」;最后用作用域线程演示「借用局部变量而不用 move」。
use std::sync::{mpsc, Arc, Mutex};
use std::thread;
fn main() {
let logs = [
"WARN disk", "INFO started", "WARN cpu", "ERROR db",
"WARN mem", "INFO done", "ERROR db", "WARN cpu",
];
let (tx, rx) = mpsc::channel();
thread::scope(|s| {
for chunk in logs.chunks(4) {
let tx = tx.clone();
s.spawn(move || {
let mut warn = 0;
for line in chunk {
if line.starts_with("WARN") {
warn += 1;
}
}
tx.send(warn).unwrap();
});
}
});
drop(tx);
let mut total = 0;
for n in rx {
total += n;
}
println!("WARN 总数: {total}");
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..8 {
let counter = Arc::clone(&counter);
handles.push(thread::spawn(move || {
let mut n = counter.lock().unwrap();
*n += 1;
}));
}
for h in handles {
h.join().unwrap();
}
println!("计数器: {}", counter.lock().unwrap());
let mut data = vec![1, 2, 3];
thread::scope(|s| {
s.spawn(|| println!("data = {:?}", data));
});
data.push(4);
println!("data 之后: {:?}", data);
}
用 rustc --edition 2021 main.rs 编出来的程序,实测输出:
WARN 总数: 4
计数器: 8
data = [1, 2, 3]
data 之后: [1, 2, 3, 4]
三段各自解决一类问题:第一段用 channel 收集局部结果,避免共享内存;第二段用 Arc<Mutex> 演示必须共享时的写法;第三段展示 thread::scope 允许线程借用栈上的 data,而且作用域结束后 data 还能继续用。下面逐个拆开。
thread::spawn 与 move:'static 到底在要求什么
最基础的起线程写法是 thread::spawn(闭包),它返回一个 JoinHandle,调用 join() 会等线程结束并拿到返回值。spawn 的签名里有一条硬约束:
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
F: Send + 'static,
T: Send + 'static,
T: Send 指线程返回的值能安全地送回主线程;F: 'static 指闭包本身不能持有任何「活不过程序结束」的借用。为什么这么严?因为 spawn 启动的线程独立于当前函数:当前函数可能已经返回、局部变量已经释放,而那个线程还在跑。如果闭包只借了一个局部变量的引用,释放之后线程再去读,就是悬垂指针。编译器不允许这种局面存在,所以要求闭包要么不借用(只用自己的东西),要么把数据的所有权搬进去。
下面这段没写 move,只借用了 data:
let data = vec![1, 2, 3];
let handle = thread::spawn(|| {
println!("{}", data.len());
});
error[E0373]: closure may outlive the current function, but it borrows
`data`, which is owned by the current function
--> t9borrow.rs:5:32
|
5 | let handle = thread::spawn(|| {
| ^^ may outlive borrowed value `data`
6 | println!("{}", data.len());
| ---- `data` is borrowed here
|
note: function requires argument type to outlive `'static`
help: to force the closure to take ownership of `data` (and any other
referenced variables), use the `move` keyword
|
5 | let handle = thread::spawn(move || {
| ++++
人话版:闭包可能活得比 main 还久,而 data 是 main 的局部变量,main 一返回它就没了。编译器怕线程拿着一个已经失效的引用去访问,所以拒绝。它给的建议也很直接:加 move,把 data 的所有权搬进闭包,这样线程自己拥有一份数据,主函数返回也不影响它。
加 move 之后有一个必须接受的后果:data 被移走了,原作用域里不能再用。再写 println!("{:?}", data) 会得到 borrow of moved value: `data`(E0382)。这不是编译器的脾气,而是所有权规则:东西只有一个主人,搬进线程之后就不再属于你了。真需要两边都用,就 clone 一份给线程——代价是多一份内存;或者用后面讲的 Arc 共享所有权。
回到主示例,第一段为什么用 thread::scope 而不是直接 spawn?因为 logs.chunks(4) 产生的是 借用 logs 的切片,不是拥有数据的 Vec。直接把它 move 进 spawn,搬走的只是切片的引用,数据本身还在栈上,照样违反 'static。真实的报错是:
error[E0597]: `logs` does not live long enough
|
12 | for chunk in logs.chunks(4) {
| ^^^^ borrowed value does not live long enough
...
22 | });
| - argument requires that `logs` is borrowed for `'static`
...
54 | }
| - `logs` dropped here while still borrowed
|
note: requirement that the value outlives `'static` introduced here
|
128 | F: Send + 'static,
人话版:chunks 借了 logs,而 spawn 要求闭包 'static,也就是「不借任何局部变量」。两条要求直接冲突。解决办法有三:把每段复制成拥有数据的 Vec;改用 thread::scope,它允许线程借用局部变量;或者一开始就让数据是 'static(比如 Box::leak 或全局常量,但通常不值得)。实际项目里,thread::scope 是处理「借用切片并行处理」最顺手的选择。
channel:把结果送回主线程,别共享内存
并发的第一原则是能不共享就不共享。线程各自算一段,把结果打包发回来,主线程串行汇总,这样没有一把锁,也就没有死锁和数据竞争。std::sync::mpsc 就是干这个的:mpsc 是 multi-producer, single-consumer,多个发送端、一个接收端。
let (tx, rx) = mpsc::channel();
thread::scope(|s| {
for chunk in logs.chunks(4) {
let tx = tx.clone();
s.spawn(move || {
let mut warn = 0;
for line in chunk {
if line.starts_with("WARN") {
warn += 1;
}
}
tx.send(warn).unwrap();
});
}
});
drop(tx);
let mut total = 0;
for n in rx {
total += n;
}
几个细节值得说清楚。第一,每个线程都要 tx.clone():channel 的发送端可以被克隆,克隆出来的每个都能独立发送,所有消息进同一个队列。tx 本身不能同时被多个线程 move,所以每个线程拿一个克隆。第二,drop(tx) 必须写:主线程手里还有一个发送端,只要它活着,接收端的 for n in rx 就永远不会结束——它在等一个可能永远不来的消息。所有发送端都 drop 之后,接收端才知道「不会再有消息了」,循环才退出。这是 mpsc 最常见的卡死原因:程序不报错,就是不结束。
第三,send 返回 Result,接收端已经 drop 时发送会失败。示例里用 unwrap,因为接收端活得比所有线程久,失败就说明程序逻辑已经坏了,panic 是合理的。如果这属于正常情况(比如主线程提前退出),就应该处理这个 Err。
channel 还有一个天然的好处:它把「谁拥有数据」变成「谁拥有消息」。发送时值被移动进队列,接收端拿走,中间没有共享引用。所以 channel 里的类型只要求 Send,不要求 Sync——它不需要被同时访问。
共享状态:Arc<Mutex<T>> 与锁的作用域
有些状态天然要被多个线程改,比如「完成了多少个任务」的计数器。这时用 Arc<Mutex<T>>:Arc 提供多所有者共享(原子引用计数),Mutex 保证同一时刻只有一个线程能改。
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..8 {
let counter = Arc::clone(&counter);
handles.push(thread::spawn(move || {
let mut n = counter.lock().unwrap();
*n += 1;
}));
}
for h in handles {
h.join().unwrap();
}
println!("计数器: {}", counter.lock().unwrap());
为什么不能直接用 Mutex?因为 Mutex<T> 本身不能被多个线程同时拥有,move 给第一个线程之后,后面的线程就拿不到了。Arc 解决「所有权只能有一个」的问题:Arc::clone 复制的是指针和引用计数,底层数据仍是同一份。引用计数归零时数据才释放。
为什么不用 Rc?Rc 的引用计数不是原子的,两个线程同时增减可能把计数算错,导致提前释放或内存泄漏。编译器用 Send trait 把这条规则落实到了类型系统里:Rc<T> 没有实现 Send,所以它进不了 spawn。真写出来是这样:
use std::rc::Rc;
use std::thread;
let rc = Rc::new(5);
thread::spawn(move || println!("{rc}"));
error[E0277]: `Rc<i32>` cannot be sent between threads safely
--> t9rc.rs:6:19
|
6 | thread::spawn(move || println!("{rc}"));
| ------------- -------^^^^^^^^^^^^^^^^^
| | |
| | `Rc<i32>` cannot be sent between threads safely
| required by a bound introduced by this call
|
= help: within `{closure@t9rc.rs:6:19: 6:26}`, the trait `Send`
is not implemented for `Rc<i32>`
note: required because it's used within this closure
人话版:这个类型不能跨线程搬运,因为它内部的引用计数没有做原子保护。编译器不是嫌麻烦,是在防一个很难复现的 bug:两个线程恰好同时克隆/释放,计数错误,程序在某个随机时刻崩溃。换成 Arc 就满足 Send 了。Cell、RefCell 也是同样的道理,它们不是 Sync,不能给多个线程同时读。
锁的作用域比锁本身更容易出错。下面这段看起来没问题,其实会死锁:
let mut n = counter.lock().unwrap();
// ... 中间有一段代码也要 counter.lock()
let again = counter.lock().unwrap();
第一次 lock() 拿到的 MutexGuard 一直活到作用域结束,还没释放就再次加锁。标准库的 Mutex 不可重入,同一个线程第二次加锁会永远等下去。修法是缩小锁的作用域:把需要保护的读写放进一个花括号块,块结束 guard 自动 drop,锁就释放了。
lock() 返回的是 Result,不是 MutexGuard 本身。别的线程持锁时 panic,锁会被标记为「中毒」,后续 lock() 返回 Err。示例里用 unwrap 简化了,生产代码要决定中毒后是恢复还是退出,别默认忽略。thread::scope:借用局部变量,不用 move
std::thread::scope 从 Rust 1.63 起稳定。它的思路是给线程划一个作用域:作用域结束前,所有子线程一定已经 join 完毕。既然编译器能保证线程不会活过作用域,就可以安全地借用作用域里的局部变量。
let mut data = vec![1, 2, 3];
thread::scope(|s| {
s.spawn(|| println!("data = {:?}", data));
});
data.push(4);
println!("data 之后: {:?}", data);
实测输出:
data = [1, 2, 3]
data 之后: [1, 2, 3, 4]
闭包没有 move,只是借了 data;scope 返回时线程已结束,借用随之结束,所以后面还能 push。这解决了两类实际痛点:一是不想把大数组克隆一份给线程;二是处理切片、引用这类本来就借来的数据。thread::spawn 做不到,因为它不保证线程什么时候结束。
作用域线程的约束依然存在:闭包和返回值都要 Send。但它放宽了 'static,因为生命周期由 scope 兜底。scope 里所有 s.spawn 的 handle 会在作用域结束时自动 join;如果某个线程 panic,scope 会把 panic 传播到主线程。写并行处理时,优先考虑 scope,它比「克隆数据 + spawn」更贴近真实需求,也少一层分配。
还有一个细节:s.spawn 返回的 handle 也可以手动 join 拿返回值;不 join 的话,作用域结束时会替你等。两种都行,但如果你需要结果,就得自己保存 handle。
Send 与 Sync:两条 trait 说了什么
Send 和 Sync 是自动 trait,编译器根据类型的组成自动推导,不需要手写实现(unsafe impl 除外,那是后面 unsafe 篇的内容)。
Send:可以搬走
类型的所有权可以安全地转移到另一个线程。i32、String、Vec<T>(当 T: Send)、Arc<T>(当 T: Send + Sync)都满足。搬走后原线程不能再碰。
Sync:可以共用
类型的 &T 可以安全地被多个线程同时持有。Mutex<T> 满足 Sync,因为它把内部访问串行化了;RefCell<T> 不满足,因为它的借用检查是运行时的、没有线程同步。
两者的关系可以记成一句话:T 是 Sync,当且仅当 &T 是 Send。所以「多个线程共享读」要求 Sync,「把所有权交给另一个线程」只要求 Send。channel 只需要 Send,因为消息是搬过去的,不共享;Arc<T> 需要 T: Send + Sync,因为多个线程既可能搬 Arc 又可能同时解引用里面的 T。
这也是为什么给类型加一个 Rc 字段,整个结构体就失去 Send:自动推导是逐字段的,有一个字段不满足,整体就不满足。报错会指向最外层类型,但真正的问题在里面的某个字段。看 = help: ... the trait `Send` is not implemented for `Rc<i32>` 那一行,就知道该把哪个字段换掉。
现象对照
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
closure may outlive the current function, but it borrows ...(E0373) | 闭包借了局部变量,而 spawn 要求 'static | 加 move 搬走所有权,或改用 thread::scope |
... does not live long enough,提示 borrowed for `'static`(E0597) | 把切片/引用 move 进线程只是搬了引用,数据仍在栈上 | 复制成拥有数据的 Vec,或用 scoped thread 借用 |
`Rc<i32>` cannot be sent between threads safely(E0277) | Rc 引用计数非原子,没有实现 Send | 换 Arc;若是内部可变性,换 Arc<Mutex<T>> |
borrow of moved value,指向 move 闭包用过的变量(E0382) | 所有权已经搬进线程,原作用域不能再读 | 提前 clone,或改用共享所有权 / 作用域线程 |
程序跑完不退出,卡在 for msg in rx | 主线程还持有发送端,接收端认为还会有消息 | 所有发送端用完就 drop,或让它们自然离开作用域 |
| 程序卡死,没有任何输出,CPU 占用很低 | 同一线程重复 lock(),或两个线程按不同顺序拿两把锁 | 缩小锁的作用域;多把锁时固定全局加锁顺序 |
cannot borrow ... as mutable more than once(E0499) | 作用域线程同时可变借用同一个变量 | 划分不重叠的切片,或给每个线程独立数据最后合并 |
thread ... panicked,join() 返回 Err | 子线程 panic,join 把失败打包返回,不自动传播 | 决定是否 unwrap;检查子线程里的 unwrap/越界/锁中毒 |
边界与代价
线程不是越多越好。每个线程都有栈空间(默认 2 MB 左右,可用 thread::Builder::new().stack_size() 调),操作系统调度也有开销。纯 CPU 任务,线程数开到核心数附近就够;I/O 密集任务可以更多,因为线程大部分时间在等。超出这个范围,收益迅速递减,甚至因为上下文切换变慢。真要高并发 I/O,异步运行时往往比「一请求一线程」更合适,但那是另一个话题。
锁的代价有两层。一层是竞争:锁被占着时其他线程阻塞,热点锁会把并行退化成串行。另一层是粒度:锁太大,等于串行;锁太小、要同时拿多把,又容易死锁。实践上先保证正确,再测量,最后才拆锁。Arc<Mutex<T>> 的每次 clone 都要做原子加一,lock 要做原子比较交换,这些在小对象、超高频路径上都是成本。能用 channel 传结果、避免共享,就别共享。
channel 也不是免费的。无界 channel(mpsc::channel())没有背压,生产速度远快于消费速度时,消息会在内存里堆积,直到把进程撑爆。需要限流就用 sync_channel(n),队列满时 send 会阻塞。另外,标准库的 mpsc 只有单消费者;要多消费者并行消费,用 crossbeam-channel 这类第三方库,或者干脆每个消费者一条 channel。
thread::scope 也不是万能。它解决借用问题,但解决不了「线程必须提前返回」之类更复杂的生命周期需求;那种场景仍然要 'static 或 Arc。它的另一个限制是所有线程必须在作用域结束前完成,没法做「后台常驻线程」。常驻线程就回到 spawn + move + channel 的组合。
最后是 panic 的边界。子线程 panic 不会让整个进程立刻退出,join() 会返回 Err,需要你决定怎么处理。主线程 panic 时,其他线程可能还在跑,进程退出前不会有清理保证。涉及文件写入、网络连接这类资源时,把清理放在 Drop 里,或者用 scope 让所有线程先汇合。
小结
thread::spawn 要求闭包 Send + 'static:要么不借用局部变量,要么用 move 把所有权搬进去。搬进去之后原变量不能再用;想两边都用就 clone 或用 Arc。借用切片并行处理时,thread::scope 比 spawn 更合适。
线程之间传结果优先用 channel:每个线程 clone 发送端,主线程记得 drop 自己那份,否则循环收不了尾。必须共享时用 Arc<Mutex<T>>,Rc 和 RefCell 跨线程会被 Send/Sync 拦住。锁的作用域尽量小,多把锁固定顺序,避免死锁。
当天可以自己验证的练习:
- 把主示例里第一段的
thread::scope换成thread::spawn,亲手读出 E0597,再改回scope。 - 去掉
drop(tx),运行程序,观察它是不是卡住不退;想想为什么接收端不知道发送端已经结束。 - 把
Arc换成Rc,读一遍 E0277,再把Mutex去掉试试,看看Arc<i32>直接*n += 1会报什么。 - 写一个两把锁、两个线程按相反顺序加锁的程序,制造死锁;再给两把锁规定统一顺序,确认死锁消失。
- 用
sync_channel(1)限制队列长度,让发送方打印发送序号,观察它什么时候被阻塞。
下一篇讲unsafe 与 FFI:和系统打交道的边界。线程、channel、锁这些工具,标准库已经替你保证了内存安全和数据安全。但有些场景绕不开它们:要调用 C 库、要操作裸指针、要实现一个标准库没有的同步原语。那时你会看到 unsafe 关键字,编译器不再替你检查,安全责任回到你手上。下一篇讲清楚这个边界在哪、怎么把 unsafe 关在一个小盒子里,以及 FFI 调用为什么会崩、怎么查。