Send,Sync 与线程安全

上一篇遗留的问题: 编译器凭什么放行

第 08 篇里, thread::spawn(move || ...) 能把 String 移进线程. 但编译器凭什么认为 String 可以安全地跨线程? 而上一篇又说过 Rc 不能跨线程--编译器又是怎么知道的?

答案就是 Send 和 Sync. 它们是类型系统里的两个"许可标签": 贴了 Send 标签的类型才能被移进线程, 贴了 Sync 标签的类型才能被多线程共享引用. thread::spawn 的签名里就写着这个要求(简化):

pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
    F: FnOnce() -> T + Send + 'static, // 闭包必须是 Send!
    T: Send,                           // 返回值也必须是 Send

正因 String 是 Send, 捕获了它的闭包也是 Send, 才能通过这个约束; 而 Rc 不是 Send, 捕获它的闭包就不满足约束, 编译器当场拒绝.

什么是标记特征(marker trait)

Send 和 Sync 的定义长这样--空的:

pub unsafe trait Send {} // 没有任何方法!
pub unsafe trait Sync {} // 同样为空

它们不要求实现任何方法, 纯粹是给类型"贴标签"--标记"这个类型具备某种属性". 编译器不靠方法, 而靠"类型有没有这个标签"来做检查. 这种没有方法, 只用于标记属性的 trait, 称为标记特征.

Send 与 Sync 的精确含义

两者极易混淆, 务必分清. 关键区别是"转移所有权"还是"共享引用":

那行精确定义值得记住: T 是 Sync, 当且仅当 &T 是 Send. 换言之, "能被多线程共享引用"等价于"它的引用能被转移到多个线程"--两个概念由此打通.

自动派生: 几乎从不手动实现

这是 Send/Sync 设计最精巧的一点. 它们由编译器自动派生: 一个类型, 只要它的所有字段都是 Send, 它就自动是 Send(Sync 同理). 这是一种"组合即安全"的递归推导.

// 自定义的结构体, 编译器自动判断它是否 Send/Sync
struct MyData {
    name: String,   // String 是 Send + Sync
    count: i32,     // i32 是 Send + Sync
}
// → MyData 的所有字段都是 Send + Sync, 所以它自动也是 Send + Sync
// 什么都不用写, 就能把 MyData 安全地用于多线程

反过来, 只要混入一个非 Send 的字段, 整个类型就自动失去 Send:

use std::rc::Rc;
struct Bad {
    shared: Rc<i32>, // Rc 不是 Send
}
// → Bad 自动不是 Send, 任何想把它跨线程的代码都会编译失败

对比 Go: 编译期 vs 运行期

这正是 Rust 与 Go 在并发安全上的分水岭:

Go                                   Rust
──                                   ────
任何值都能传进 goroutine             只有 Send 类型能进线程
数据竞争靠 -race 在运行时检测         数据竞争在编译期被 Send/Sync 拦截
漏检 → 线上偶发, 极难复现的 bug       编译不过 → 问题在提交前就暴露

快速回顾

• 定位: Send/Sync 是编译器判断"类型能否跨线程"的依据, thread::spawn 的约束里写着它们.
• 标记特征: 无方法, 纯粹给类型"贴资质标签", 编译器据标签放行或拦截.
• 含义: Send = 所有权可转移到别的线程; Sync = 可被多线程共享引用; T: Sync ⟺ &T: Send.
• 自动派生: 所有字段都 Send/Sync, 则类型自动 Send/Sync; 混入一个非 Send 字段则整体失去--安全性沿类型结构自动传播.
• 对比 Go: 数据竞争从"运行时靠 -race 检测"变为"编译期被 Send/Sync 拦截", 是硬保证而非靠运气.
• 实践: 几乎不手动实现; 读懂 "cannot be sent" 报错, 把非 Send 类型换成线程安全对应物(Rc→Arc 等).

动手练习

1. 用一句话分别说清 Send 和 Sync 的区别, 并举一个"是 Sync 但不是 Send"的例子.

2. 下面这个结构体是 Send 吗? 为什么?

   struct Task { id: u64, name: String, payload: Vec<u8>, }

3. 下面代码报错 "Rc<i32> cannot be sent between threads safely". 解释根因并修复.

   use std::rc::Rc; use std::thread; let data = Rc::new(5); let d = Rc::clone(&data); thread::spawn(move || println!("{d}"));

use std::sync::Arc;
use std::thread;
let data = Arc::new(5);
let d = Arc::clone(&data);
thread::spawn(move || println!("{d}")); // OK, Arc 是 Send

4. 思考: 为什么 Rust 能在编译期就消灭数据竞争, 而 Go 只能靠运行时的 race detector?