引言
并发编程中最棘手的问题是数据竞争和线程安全------多个线程同时访问共享数据，至少一个进行写入，且没有同步机制。传统语言依赖程序员的谨慎和运行时检测，导致难以发现的 bug 和生产环境崩溃。Rust 通过类型系统在编译期解决这个问题，引入了两个自动派生的 marker trait：Send 和 Sync。Send 表示类型的所有权可以在线程间转移，Sync 表示类型可以被多个线程同时不可变地访问。这两个 trait 不包含任何方法，纯粹是编译器的标记，用于静态检查线程安全性。编译器自动为大多数类型实现它们，但对某些类型（如 Rc、裸指针）拒绝实现，防止不安全的跨线程使用。理解 Send 和 Sync 的语义、它们的自动推导规则、何时需要手动实现、如何设计线程安全的类型，是编写正确并发代码的基础。本文深入探讨这两个 trait 的工作原理、实现细节、常见模式和最佳实践。
Send Trait：所有权的跨线程转移
Send trait 标记一个类型的值可以安全地从一个线程转移到另一个线程。"转移"意味着所有权的移动------发送线程放弃所有权，接收线程获得所有权。大多数 Rust 类型都是 Send 的------整数、字符串、Vec、Box、甚至包含 Send 类型的结构体和枚举。
编译器自动推导 Send。如果一个类型的所有字段都是 Send，那么这个类型自动是 Send。这种组合性让 Send 的推导非常自然------不需要为每个类型手动实现。但某些类型明确不是 Send------Rc<T> 使用非原子引用计数，跨线程转移会导致数据竞争；裸指针（*const T、*mut T）没有任何安全保证，不能跨线程发送。
Send 的语义是所有权转移，不是共享。发送一个值意味着原线程不再能访问它。这种独占性保证了没有数据竞争------任何时刻只有一个线程拥有值。std::thread::spawn 要求闭包是 Send，因为闭包会在新线程中执行，捕获的变量必须能安全转移。
手动实现 Send 需要 unsafe。这是因为 Send 是安全承诺------编译器信任这个标记来允许跨线程转移。如果实现错误，会导致未定义行为。只有在类型确实可以安全跨线程转移，但编译器无法推导时，才应该手动实现。典型场景是包含裸指针的自定义智能指针------如果指针指向的数据本身是线程安全的，类型可以是 Send。
Sync Trait：共享引用的并发访问
Sync trait 标记一个类型可以被多个线程同时通过不可变引用（&T）访问。换句话说，T: Sync 意味着 &T: Send------类型的共享引用可以安全地发送到其他线程。大多数不可变类型都是 Sync 的------整数、字符串字面量、不可变结构体。
Sync 的自动推导规则类似 Send：如果所有字段都是 Sync，类型自动是 Sync。但某些类型明确不是 Sync------Cell 和 RefCell 提供内部可变性但没有同步机制，多线程访问会导致数据竞争；Rc<T> 的引用计数不是线程安全的，共享引用仍可能被克隆导致竞争。
原子类型（AtomicUsize、AtomicBool）和互斥锁（Mutex<T>、RwLock<T>）是 Sync 的关键组件。原子类型使用硬件级别的原子操作，保证多线程安全。Mutex<T> 通过运行时锁保护内部数据，即使 T 不是 Sync，Mutex<T> 仍然是 Sync------因为访问需要先获取锁。
Send 和 Sync 的关系是微妙的。T: Sync 不意味着 T: Send（例如 MutexGuard 是 Sync 但不是 Send），T: Send 也不意味着 T: Sync（例如 Cell<i32> 是 Send 但不是 Sync）。它们是正交的概念------一个关于所有权转移，一个关于共享访问。
编译器如何强制线程安全
编译器在函数边界检查 Send 和 Sync。std::thread::spawn 的签名要求闭包 F: Send + 'static------闭包必须可以发送到新线程，且捕获的变量必须拥有足够长的生命周期。如果尝试发送不是 Send 的类型（如 方式。与 Rc<T> 不同，Arc<T> 使用原子引用计数，是 Send + Sync（当 T: Send + Sync 时）。多个线程可以持有 Arc<T> 的克隆，通过共享引用访问内部数据。但如果需要修改数据，必须配合 Mutex 或 RwLock------Arc<Mutex<T>> 是线程安全的可变共享模式。
生命周期和 Send/Sync 的交互也很重要。引用本身是 Send + Sync 的（当引用的类型满足条件时），但生命周期必须足够长。'static 生命周期保证数据在整个程序运行期间有效，适合跨线程使用。非静态引用需要确保所有线程在数据失效前完成，通常通过 scoped threads 实现。
深度实践：线程安全类型的设计与实现
toml
# Cargo.toml
[package]
name = "send-sync-traits"
version = "0.1.0"
edition = "2021"
[dependencies]
rust
// src/lib.rs
//! Send 与 Sync trait 的深度实践
use std::sync::{Arc, Mutex, RwLock};
use std::cell::Cell;
use std::rc::Rc;
use std::marker::PhantomData;
/// 示例 1: 理解 Send 和 Sync 的区别
/// Cell<T> 是 Send 但不是 Sync
fn demonstrate_cell() {
let cell = Cell::new(42);
// 可以发送到另一个线程
std::thread::spawn(move || {
cell.set(100);
});
// 但不能共享引用
// let cell_ref = &cell;
// std::thread::spawn(move || {
// cell_ref.set(200); // 编译错误！Cell<i32> 不是 Sync
// });
}
/// Rc<T> 既不是 Send 也不是 Sync
fn demonstrate_rc() {
let rc = Rc::new(42);
// 不能发送到另一个线程
// std::thread::spawn(move || {
// println!("{}", *rc); // 编译错误！Rc<i32> 不是 Send
// });
// 也不能共享引用跨线程
// let rc_ref = &rc;
// std::thread::spawn(move || {
// println!("{}", **rc_ref); // 编译错误！Rc<i32> 不是 Sync
// });
}
/// 示例 2: 线程安全的智能指针
pub struct ThreadSafeBox<T> {
ptr: *mut T,
}
impl<T> ThreadSafeBox<T> {
pub fn new(value: T) -> Self {
let boxed = Box::new(value);
Self {
ptr: Box::into_raw(boxed),
}
}
pub fn get(&self) -> &T {
unsafe { &*self.ptr }
}
}
impl<T> Drop for ThreadSafeBox<T> {
fn drop(&mut self) {
unsafe {
let _ = Box::from_raw(self.ptr);
}
}
}
// SAFETY: T 是 Send，所以 ThreadSafeBox<T> 可以安全发送到其他线程
unsafe impl<T: Send> Send for ThreadSafeBox<T> {}
// SAFETY: T 是 Sync，所以 ThreadSafeBox<T> 的共享引用可以安全跨线程
unsafe impl<T: Sync> Sync for ThreadSafeBox<T> {}
/// 示例 3: 线程安全的计数器
pub struct ThreadSafeCounter {
value: Mutex<usize>,
}
impl ThreadSafeCounter {
pub fn new() -> Self {
Self {
value: Mutex::new(0),
}
}
pub fn increment(&self) {
let mut value = self.value.lock().unwrap();
*value += 1;
}
pub fn get(&self) -> usize {
*self.value.lock().unwrap()
}
}
// Mutex<T> 自动是 Sync，所以 ThreadSafeCounter 自动是 Sync
// 编译器自动推导，无需手动实现
/// 示例 4: 读写锁优化的缓存
pub struct ThreadSafeCache<K, V> {
data: RwLock<std::collections::HashMap<K, V>>,
}
impl<K, V> ThreadSafeCache<K, V>
where
K: Eq + std::hash::Hash,
{
pub fn new() -> Self {
Self {
data: RwLock::new(std::collections::HashMap::new()),
}
}
pub fn get(&self, key: &K) -> Option<V>
where
V: Clone,
{
self.data.read().unwrap().get(key).cloned()
}
pub fn insert(&self, key: K, value: V) {
self.data.write().unwrap().insert(key, value);
}
pub fn len(&self) -> usize {
self.data.read().unwrap().len()
}
}
// RwLock 自动使类型 Sync
/// 示例 5: 不满足 Send/Sync 的类型标记
pub struct NotThreadSafe<T> {
data: T,
_marker: PhantomData<*const ()>, // 使类型不是 Send/Sync
}
impl<T> NotThreadSafe<T> {
pub fn new(data: T) -> Self {
Self {
data,
_marker: PhantomData,
}
}
pub fn get(&self) -> &T {
&self.data
}
}
// PhantomData<*const ()> 不是 Send/Sync，所以 NotThreadSafe 也不是
/// 示例 6: Arc 的正确使用
pub fn demonstrate_arc() {
let data = Arc::new(Mutex::new(vec![1, 2, 3]));
let mut handles = vec![];
for i in 0..10 {
let data = Arc::clone(&data);
let handle = std::thread::spawn(move || {
let mut vec = data.lock().unwrap();
vec.push(i);
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
let final_data = data.lock().unwrap();
println!("最终数据长度: {}", final_data.len());
}
/// 示例 7: Scoped Threads 与非静态引用
pub fn demonstrate_scoped_threads() {
let mut data = vec![1, 2, 3, 4, 5];
std::thread::scope(|s| {
// 可以借用非 'static 数据
s.spawn(|| {
println!("线程 1: {:?}", data);
});
s.spawn(|| {
data.push(6); // 可变借用
});
}); // scope 结束确保所有线程完成
println!("主线程: {:?}", data);
}
/// 示例 8: 条件编译与平台特定的线程安全
#[cfg(target_has_atomic = "ptr")]
pub struct AtomicPtr<T> {
ptr: std::sync::atomic::AtomicPtr<T>,
}
#[cfg(target_has_atomic = "ptr")]
impl<T> AtomicPtr<T> {
pub fn new(ptr: *mut T) -> Self {
Self {
ptr: std::sync::atomic::AtomicPtr::new(ptr),
}
}
pub fn load(&self) -> *mut T {
self.ptr.load(std::sync::atomic::Ordering::Acquire)
}
pub fn store(&self, ptr: *mut T) {
self.ptr.store(ptr, std::sync::atomic::Ordering::Release);
}
}
#[cfg(target_has_atomic = "ptr")]
unsafe impl<T: Send> Send for AtomicPtr<T> {}
#[cfg(target_has_atomic = "ptr")]
unsafe impl<T: Send> Sync for AtomicPtr<T> {}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_thread_safe_counter() {
let counter = Arc::new(ThreadSafeCounter::new());
let mut handles = vec![];
for _ in 0..10 {
let counter = Arc::clone(&counter);
let handle = std::thread::spawn(move || {
for _ in 0..1000 {
counter.increment();
}
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
assert_eq!(counter.get(), 10000);
}
#[test]
fn test_thread_safe_cache() {
let cache = Arc::new(ThreadSafeCache::new());
let mut handles = vec![];
// 写入线程
for i in 0..10 {
let cache = Arc::clone(&cache);
let handle = std::thread::spawn(move || {
cache.insert(i, i * 2);
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
// 验证
assert_eq!(cache.len(), 10);
assert_eq!(cache.get(&5), Some(10));
}
#[test]
fn test_thread_safe_box() {
let boxed = ThreadSafeBox::new(42);
let boxed = Arc::new(boxed);
let boxed_clone = Arc::clone(&boxed);
let handle = std::thread::spawn(move || {
assert_eq!(*boxed_clone.get(), 42);
});
handle.join().unwrap();
}
}
rust
// examples/send_sync_demo.rs
use send_sync_traits::*;
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;
fn main() {
println!("=== Send 与 Sync Trait 演示 ===\n");
demo_basic_concepts();
demo_arc_mutex_pattern();
demo_concurrent_cache();
demo_scoped_threads();
}
fn demo_basic_concepts() {
println!("演示 1: 基本概念\n");
// Send: 可以跨线程转移所有权
let value = String::from("Hello");
let handle = thread::spawn(move || {
println!(" 新线程接收到: {}", value);
});
handle.join().unwrap();
// Sync: 可以跨线程共享引用
let shared = Arc::new(42);
let shared_clone = Arc::clone(&shared);
let handle = thread::spawn(move || {
println!(" 新线程访问共享数据: {}", *shared_clone);
});
handle.join().unwrap();
println!();
}
fn demo_arc_mutex_pattern() {
println!("演示 2: Arc<Mutex<T>> 模式\n");
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
println!(" 启动 5 个线程，每个增加计数器 100 次");
for id in 0..5 {
let counter = Arc::clone(&counter);
let handle = thread::spawn(move || {
for _ in 0..100 {
let mut num = counter.lock().unwrap();
*num += 1;
}
println!(" 线程 {} 完成", id);
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!(" 最终计数: {}\n", *counter.lock().unwrap());
}
fn demo_concurrent_cache() {
println!("演示 3: 并发缓存\n");
let cache = Arc::new(ThreadSafeCache::new());
// 写入线程
let cache_writer = Arc::clone(&cache);
let writer = thread::spawn(move || {
for i in 0..5 {
cache_writer.insert(format!("key{}", i), i * 10);
thread::sleep(Duration::from_millis(10));
}
});
// 读取线程
let cache_reader = Arc::clone(&cache);
let reader = thread::spawn(move || {
thread::sleep(Duration::from_millis(20));
for i in 0..5 {
if let Some(value) = cache_reader.get(&format!("key{}", i)) {
println!(" 读取: key{} = {}", i, value);
}
}
});
writer.join().unwrap();
reader.join().unwrap();
println!(" 缓存最终大小: {}\n", cache.len());
}
fn demo_scoped_threads() {
println!("演示 4: Scoped Threads\n");
let mut numbers = vec![1, 2, 3, 4, 5];
thread::scope(|s| {
// 只读线程
s.spawn(|| {
let sum: i32 = numbers.iter().sum();
println!(" 只读线程计算和: {}", sum);
});
// 修改线程
s.spawn(|| {
for num in &mut numbers {
*num *= 2;
}
println!(" 修改线程将所有数字翻倍");
});
});
println!(" 最终数据: {:?}\n", numbers);
}实践中的专业思考
理解自动推导 ：大多数时候不需要手动实现 Send/Sync。如果编译器拒绝，说明类型确实不安全，应该重新设计而非强制实现。
Arc<Mutex> 是标准模式 ：需要跨线程共享可变数据时，这是最常用的模式。Arc 提供共享所有权，Mutex 提供独占访问。
读多写少用 RwLock ：如果数据大部分时间是读取，RwLock 允许多个读者并发，性能更好。
手动实现需要极度谨慎：只在确实理解类型的线程安全性，且编译器无法推导时手动实现。错误的实现导致数据竞争和未定义行为。
文档化线程安全性假设 ：如果类型包含 unsafe 代码或手动实现 Send/Sync，必须详细文档化安全性假设和不变量。
使用静态分析工具：Clippy 和 Miri 能检测某些线程安全问题。在 CI 中集成这些工具。
结语
Send 和 Sync 是 Rust 并发安全的基石，它们将线程安全从运行时问题提升为编译期检查。通过类型系统强制执行线程安全规则，Rust 消除了整个类别的并发 bug------数据竞争、不同步的共享访问、跨线程使用不安全类型。理解这两个 trait 的语义、掌握线程安全类型的设计模式、学会在需要时正确手动实现，是编写可靠并发代码的关键。这正是 Rust 的哲学------让正确的做法成为简单的做法，让错误的做法在编译期就被拒绝，构建无畏并发的系统。