Rust / 技术文章
Rust Send 和 Sync 到底怎么用
Rust 多线程开发时,最常见的问题之一是“这个值为什么不能传给另一个线程”或“为什么加了引用后编译器又拒绝了”。这篇内容面向正在编写 Rust 并发程序的后端与系统开发者,重点解释 Send 与 Sync 分别约束什么、哪些标准类型满足这些约束,以及怎样根据编译器错误判断需要移动、共享还是加同步。读完后,你可以独立分析一个类型能否跨线程传递,并正确组织常见的 Arc、Mutex 与线程入口代码。
Send 解决什么问题
Send 表示一个类型的值可以安全地从一个线程转移到另一个线程。这里强调的是“转移所有权”,而不是多个线程同时访问同一个值。
线程 API 中常见的闭包边界就体现了这一点:
use std::thread;
fn main() {
let message = String::from("hello");
let handle = thread::spawn(move || {
println!("{message}");
});
handle.join().unwrap();
}预期输出:
helloString 实现了 Send,所以可以通过 move 将它的所有权交给新线程。原线程随后不再拥有这个 String。
因此可以把 Send 理解为:这个值适合把所有权交给另一个线程继续使用。
Sync 解决什么问题
Sync 关注的是共享引用。一个类型 T 实现 Sync,意味着 &T 可以安全地被多个线程同时持有。
Rust 中经常用一个等价关系理解它:
T: Sync 等价于 &T: Send。
也就是说,把一个共享引用送到另一个线程是否安全,是理解 Sync 的关键。
例如只读的 String 可以通过 Arc 在多个线程之间共享:
use std::sync::Arc;
use std::thread;
fn main() {
let message = Arc::new(String::from("hello"));
let mut handles = Vec::new();
for _ in 0..2 {
let shared = Arc::clone(&message);
handles.push(thread::spawn(move || {
println!("{shared}");
}));
}
for handle in handles {
handle.join().unwrap();
}
}预期输出可能为:
hello
hello这里不是 Arc 把所有类型都变成线程安全类型,而是它提供了原子引用计数;底层 String 本身满足共享访问所需的线程安全约束。
Send 和 Sync 不是一回事
判断并发类型时,最好先问两个不同的问题。
| 问题 | 关注的 trait | 含义 |
|---|---|---|
| 能不能把值的所有权交给另一个线程 | Send |
跨线程移动值 |
能不能让多个线程共享 &T |
Sync |
跨线程共享引用 |
| 多线程共享后还能不能修改 | 不只看 Sync |
还要看内部可变性与同步机制 |
因此,“能跨线程移动”和“能被多个线程安全共享”不能混为一谈。
典型例子是 Arc<Mutex<T>>。Arc 解决的是多个线程共同持有所有权,Mutex 解决的是对共享可变状态进行互斥访问:
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let counter = Arc::new(Mutex::new(0));
let mut handles = Vec::new();
for _ in 0..2 {
let counter = Arc::clone(&counter);
handles.push(thread::spawn(move || {
let mut value = counter.lock().unwrap();
*value += 1;
}));
}
for handle in handles {
handle.join().unwrap();
}
println!("{}", *counter.lock().unwrap());
}预期输出:
2这里的职责可以拆开看:Arc 管共享所有权,Mutex 管并发修改,Send 与 Sync 则描述这些类型组合后是否满足线程边界要求。
哪些类型会触发典型错误
Rust 会拒绝把不具备线程安全保证的类型跨线程传递。最常见的例子是 Rc<T> 和 RefCell<T>。
Rc<T> 使用非原子的引用计数,因此不能安全地直接用于跨线程共享;多线程环境通常使用 Arc<T>。
可以从编译器错误中快速识别这类问题:
use std::rc::Rc;
use std::thread;
fn main() {
let value = Rc::new(String::from("hello"));
thread::spawn(move || {
println!("{value}");
});
}预期结果:编译失败,并指出 Rc<String> 不满足线程要求,错误信息通常会沿着 Rc 的类型关系指出缺失的 Send 约束。
这类错误不要只理解成“Rust 不让我开线程”。更准确的理解是:线程 API 要求闭包捕获的状态满足特定 trait,而当前类型没有提供对应的线程安全保证。
怎么根据使用场景选择类型
可以先按“所有权如何流动”来判断,而不是先背类型名称。
| 场景 | 常见选择 | 原因 |
|---|---|---|
| 一个值只交给新线程 | T + move |
转移所有权,关注 Send |
| 多线程只读共享 | Arc<T> |
共享所有权,要求 T 满足相应线程安全约束 |
| 多线程共享并修改 | Arc<Mutex<T>> |
共享所有权 + 互斥修改 |
| 多线程共享并发读写,读多写少 | Arc<RwLock<T>> |
读写锁区分读与写 |
| 单线程内部可变 | Rc<RefCell<T>> |
适合单线程,不用于直接跨线程 |
例如下面这段代码中,Arc 是因为多个线程都需要持有同一份状态,而 Mutex 是因为状态会被修改:
use std::sync::{Arc, Mutex};
struct State {
count: usize,
}
fn main() {
let state = Arc::new(Mutex::new(State { count: 0 }));
println!("{}", state.lock().unwrap().count);
}预期输出:
0设计并发代码时,不要为了消除编译错误机械地加 Arc<Mutex<_>>。先确认数据是否真的需要跨线程共享,以及是否真的存在共享修改;很多场景只需要所有权移动,或者只读共享即可。
遇到 Send 和 Sync 报错怎么查
排查时可以按三个问题逐层缩小范围。
第一,看报错发生在“把值送进线程”还是“把引用送进线程”。前者通常与 Send 有关,后者通常与 Sync 有关。
第二,检查被捕获的数据中是否藏着不满足约束的成员。一个结构体是否实现 Send 或 Sync,往往取决于它内部字段的线程安全属性,因此问题可能不在你直接看到的外层类型。
第三,再决定是改变所有权模型,还是增加同步机制。例如:
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let data = Arc::new(Mutex::new(vec![1, 2, 3]));
let worker_data = Arc::clone(&data);
let handle = thread::spawn(move || {
worker_data.lock().unwrap().push(4);
});
handle.join().unwrap();
println!("{:?}", data.lock().unwrap());
}预期输出:
[1, 2, 3, 4]真正重要的是识别线程边界上的数据关系:是“移动一次”,还是“多个线程共享”,还是“多个线程共享并修改”。一旦先把这个关系说清楚,Send、Sync、Arc 和 Mutex 的组合通常就会自然很多。