Send 与 Sync 含义
面试题
请解释 Rust 中 Send 和 Sync trait 的含义,它们是如何在编译期保证线程安全的?
考察意图
Send 和 Sync 是 Rust 并发安全的基石。面试官想看候选人能否清晰区分两者的语义——Send 关于所有权转移,Sync 关于共享引用——以及编译器如何利用它们在编译期排除数据竞争。
答题要点
Send 和 Sync 的定义
// Send:类型的值可以安全地在线程间转移所有权
// 如果 T: Send,那么 T 可以被 move 到另一个线程
// Sync:类型的引用可以安全地在多个线程间共享
// 如果 T: Sync,那么 &T 可以安全地被多个线程同时持有
// 等价于:T: Sync ⟺ &T: Send
// 它们是自动 trait(auto trait)和标记 trait(marker trait)
// 编译器自动为满足条件的类型实现
// 没有方法需要实现——纯粹是编译期类型标记
fn main() {
println!("Send: 值可以跨线程移动");
println!("Sync: 引用可以跨线程共享");
}常见类型的 Send/Sync 实现
| 类型 | Send | Sync | 原因 |
|---|---|---|---|
i32, f64, bool | 是 | 是 | 基础类型,无共享状态 |
String, Vec<T> | 是(T: Send) | 是(T: Sync) | 拥有所有权 |
Box<T> | 是(T: Send) | 是(T: Sync) | 拥有所有权 |
Arc<T> | 是(T: Send + Sync) | 是(T: Send + Sync) | 原子引用计数 |
Mutex<T> | 是(T: Send) | 是(T: Send) | 互斥锁保护 |
Rc<T> | 否 | 否 | 非原子引用计数 |
RefCell<T> | 是(T: Send) | 否 | 非线程安全的借用检查 |
Cell<T> | 是(T: Send) | 否 | 非线程安全的内部可变性 |
*const T, *mut T | 否 | 否 | 裸指针无安全保证 |
MutexGuard<T> | 否 | 是(T: Sync) | 某些系统要求同线程解锁 |
Send 的作用
use std::thread;
fn main() {
// === Send 类型可以跨线程移动 ===
let data = String::from("hello"); // String: Send
let handle = thread::spawn(move || {
// data 的所有权被移动到新线程
println!("线程中: {}", data);
});
handle.join().unwrap();
// === 非 Send 类型不能跨线程 ===
// use std::rc::Rc;
// let rc = Rc::new(42); // Rc: !Send
// thread::spawn(move || {
// println!("{}", rc); // 编译错误:Rc 不是 Send
// });
// 因为 Rc 的引用计数不是原子的,跨线程操作会数据竞争
// === 用 Arc 替代 Rc 实现跨线程共享 ===
use std::sync::Arc;
let arc = Arc::new(42); // Arc: Send + Sync
let arc2 = Arc::clone(&arc);
let handle = thread::spawn(move || {
println!("Arc 线程中: {}", arc2);
});
handle.join().unwrap();
println!("Arc 主线程: {}", arc);
}Sync 的作用
use std::sync::Arc;
use std::thread;
fn main() {
// === Sync 类型的引用可以跨线程共享 ===
// i32 是 Sync 的,&i32 可以安全地在多个线程中读取
let data = vec![1, 2, 3, 4, 5];
let shared = Arc::new(data); // Vec<i32>: Sync
let mut handles = vec![];
for i in 0..3 {
let shared_ref = Arc::clone(&shared);
let handle = thread::spawn(move || {
// 多个线程同时持有 &Vec<i32>(通过 Arc)
println!("线程 {}: {:?}", i, *shared_ref);
});
handles.push(handle);
}
for h in handles {
h.join().unwrap();
}
// === RefCell 不是 Sync ===
// use std::cell::RefCell;
// let cell = Arc::new(RefCell::new(0)); // 编译错误
// RefCell 的借用检查不是线程安全的
// 多个线程同时 borrow_mut 会导致数据竞争
// === Mutex 让非 Sync 类型也能安全共享 ===
use std::sync::Mutex;
let counter = Arc::new(Mutex::new(0)); // Mutex<i32>: Sync
let mut handles = vec![];
for _ in 0..5 {
let counter = Arc::clone(&counter);
let handle = thread::spawn(move || {
let mut num = counter.lock().unwrap();
*num += 1;
});
handles.push(handle);
}
for h in handles {
h.join().unwrap();
}
println!("最终计数: {}", *counter.lock().unwrap());
}编译器如何利用 Send/Sync
// thread::spawn 的签名要求闭包满足 Send + 'static
// pub fn spawn<F, T>(f: F) -> JoinHandle<T>
// where
// F: FnOnce() -> T + Send + 'static,
// T: Send + 'static,
// 这意味着:
// 1. 闭包捕获的所有值必须是 Send 的
// 2. 闭包返回值必须是 Send 的
// 3. 所有值必须满足 'static(不含短生命周期引用)
// 如果你尝试发送非 Send 类型,编译器会报错
// 错误信息明确指出哪个类型不满足 Send
// tokio::spawn 也有类似要求:
// pub fn spawn<T>(future: T) -> JoinHandle<T::Output>
// where
// T: Future + Send + 'static,
// T::Output: Send + 'static,
fn main() {
println!("Send/Sync 约束在编译期排除数据竞争");
println!("不满足约束的代码直接编译失败");
}手动实现 Send/Sync
// 极少数情况下需要手动实现 Send/Sync
// 这需要 unsafe,因为你在向编译器保证线程安全
struct MyType {
ptr: *mut i32, // 裸指针默认 !Send + !Sync
}
// 向编译器保证 MyType 可以安全跨线程
// 你必须确保 ptr 指向的数据的访问是安全的
unsafe impl Send for MyType {}
unsafe impl Sync for MyType {}
// 也可以显式声明类型不是 Send/Sync
// impl !Send for MyType {} // 需要 nightly
fn main() {
println!("手动 impl Send/Sync 需要 unsafe");
println!("因为编译器无法验证你的保证");
}常见追问
追问一:为什么 Mutex<T> 只要求 T: Send 不要求 T: Sync?
因为 Mutex 保证同一时刻只有一个线程访问数据(通过锁)。数据不会被同时共享读取,所以不需要 Sync。只需要 Send 保证数据可以安全地从一个线程转移到另一个线程(获取锁和释放锁时)。
追问二:为什么 Arc<T> 要求 T: Send + Sync?
Arc 允许多个线程同时持有引用(共享),所以需要 T: Sync(多个 &T 同时存在)。同时 Arc 的 clone/drop 涉及跨线程的引用计数操作,所以需要 T: Send。
追问三:一个类型是 Send 但不是 Sync 意味着什么?
意味着这个类型可以安全地移动到另一个线程,但不能同时被多个线程通过引用访问。典型例子:RefCell<T>——可以移动到另一个线程,但它的 borrow 检查不是线程安全的。
基本示例
use std::sync::{Arc, Mutex};
use std::thread;
// 验证类型的 Send/Sync 特性
fn assert_send<T: Send>() {}
fn assert_sync<T: Sync>() {}
fn main() {
// 编译通过 = 满足约束
assert_send::<i32>();
assert_sync::<i32>();
assert_send::<String>();
assert_sync::<String>();
assert_send::<Vec<i32>>();
assert_sync::<Vec<i32>>();
assert_send::<Arc<i32>>();
assert_sync::<Arc<i32>>();
assert_send::<Mutex<i32>>();
assert_sync::<Mutex<i32>>();
// 以下编译失败(取消注释即可验证):
// assert_send::<std::rc::Rc<i32>>(); // Rc 不是 Send
// assert_sync::<std::rc::Rc<i32>>(); // Rc 不是 Sync
// assert_sync::<std::cell::RefCell<i32>>(); // RefCell 不是 Sync
// assert_send::<*const i32>(); // 裸指针不是 Send
// 实际应用
let data = Arc::new(Mutex::new(Vec::new()));
let mut handles = vec![];
for i in 0..3 {
let data = Arc::clone(&data);
handles.push(thread::spawn(move || {
data.lock().unwrap().push(i);
}));
}
for h in handles {
h.join().unwrap();
}
let result = data.lock().unwrap();
println!("结果: {:?}", *result);
}常见问题
问题一:Send 和 Sync 有运行时开销吗?
没有。它们是标记 trait(marker trait),没有任何方法或数据。完全是编译期的类型系统约束,零运行时开销。
问题二:几乎所有类型都是 Send + Sync 吗?
大部分拥有所有权的类型是 Send + Sync。主要的例外是:Rc(非原子引用计数)、Cell/RefCell(非线程安全的内部可变性)、裸指针(无安全保证)、某些 FFI 类型。
适用场景
- 多线程编程:确保跨线程数据传递安全
- 异步编程:tokio::spawn 要求 Future: Send
- 并发数据结构:设计线程安全的类型
- 库 API 设计:约束泛型参数的线程安全性
注意事项
- Send 关于所有权转移,Sync 关于引用共享
- T: Sync 等价于 &T: Send
- Rc 不是 Send/Sync,用 Arc 替代
- RefCell 不是 Sync,用 Mutex 替代
- 手动 impl Send/Sync 需要 unsafe
- 编译器自动为满足条件的类型实现
总结
Send 表示类型的值可以安全地跨线程移动所有权,Sync 表示类型的引用可以安全地被多个线程同时持有。两者是自动实现的标记 trait,零运行时开销。thread::spawn 和 tokio::spawn 通过 Send + 'static 约束在编译期排除数据竞争。Rc 不是 Send/Sync(非原子引用计数),用 Arc 替代。RefCell 不是 Sync(非线程安全借用检查),用 Mutex 替代。Mutex<T> 只要求 T: Send(锁保证互斥),Arc<T> 要求 T: Send + Sync(允许共享读取)。手动 impl Send/Sync 需要 unsafe。