Rust中的 Send 和 Sync trait 详解

Rust中的标记 trait（Marker Trait）Send 和 Sync 是并发安全的核心基石。用于标记类型的并发安全属性，让编译器在编译时检查线程间数据传递的合法性，从根源上避免数据竞争（Data Race）。

• Send：类型的值能不能在线程之间“移动所有权”。
• Sync：类型的值能不能在多个线程中“共享引用 &T”。
  • 对同一个值进行并发访问（只读）是内存安全的。
  • 并发修改仍然要靠锁/原子/其他机制。

Send

一个类型 T 是 Send，表示把 T 的一个 值 从一个线程移动到另一个线程，不会引发数据竞争或内存安全问题。

• 移动的是 所有权，而不是引用。
• 移动之后，原线程不能再用这个值（所有权已经被 move）。

绝大多数类型自动实现 Send，以下一些例外（!Send）：

• Rc<T>：引用计数是非原子操作，跨线程转移会导致计数竞争（数据竞争）。
• RefCell<T>/Cell<T>：内部可变性无同步机制，跨线程转移后，多个线程可能同时修改数据。
• 裸指针 *const T/*mut T：无安全保证，直接跨线程转移可能导致悬垂指针或数据竞争。
• UnsafeCell<T>：内部可变性的底层实现，本身 !Send（但基于它的线程安全类型如 Mutex 会手动实现 Send）。

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    // Vec<i32> 是 Send，通过move把所有权移到线程中
    let handle = thread::spawn(move || {
        println!("{:?}", v);
    });

    handle.join().unwrap();
}

sync

一个类型 T 是 Sync，表示可以安全地被多个线程共享（即 &T 是 Send）。即，如果一个类型的引用 &T 能安全跨线程传递，那么这个类型就是 Sync（多个线程持有 &T 不会导致数据竞争）。

任何允许通过 共享引用 &T 获得可变访问 且没有同步保护的类型，都不是 Sync：

• Cell<T> / RefCell<T>：允许通过 &T 改变内部数据（“内部可变性”），但不保证线程安全。
• Rc<T>：通过共享引用可以克隆 Rc 得到更多引用，从而在多线程下导致竞争。
• 非线程安全的 FFI 对象，如果通过 & 能调用会修改内部状态的方法。

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let data = Arc::new(Mutex::new(5)); // Arc<Mutex<i32>>
    let data_clone = data.clone();

    thread::spawn(move || {
        let mut guard = data_clone.lock().unwrap(); // 加锁，独占访问
        *guard += 1;
    }).join().unwrap();

    println!("{}", data.lock().unwrap()); // 输出 6
}

auto trait

Send 和 Sync 都是 auto trait，编译器会根据类型的组成部分自动推导实现。

性质	含义	常见例子
Send + Sync	可以在线程间移动，也可以多线程共享引用	i32, Mutex<T>等
Send + !Sync	可以在线程间移动，但不能多线程共享引用	一些 *mut T封装，Sender<T>
!Send + Sync	不能跨线程移动；不移动，只读共享是安全的（较少见）	少数特殊 FFI 对象
!Send + !Sync	既不能跨线程移动，也不能多线程共享引用	Rc<RefCell<T>> 等

只有在特殊情况下（写 底层库 / FFI 封装 / 自己的锁和原子数据结构 时）才会需要手动实现Send 和 Sync ：

• unsafe impl Send / unsafe impl Sync 是非常严肃的承诺
• 要自己保证所有可能的并发访问路径都不会产生数据竞争、悬垂指针等。

use std::sync::Mutex;

// 自定义类型：用 Mutex 保护裸指针（裸指针本身 !Send/!Sync）
struct SafePtr<T>(Mutex<*mut T>);

impl<T> SafePtr<T> {
    fn new(value: T) -> Self {
        let ptr = Box::into_raw(Box::new(value)); // 裸指针指向堆内存
        SafePtr(Mutex::new(ptr))
    }

    // 安全访问：通过 Mutex 加锁，保证独占访问
    fn get(&self) -> Option<&T> {
        let guard = self.0.lock().ok()?;
        unsafe { (*guard).as_ref() } // 裸指针解引用需 unsafe，但锁保证安全
    }
}

// 手动实现 Send/Sync：因为内部用 Mutex 保护，访问裸指针是线程安全的
unsafe impl<T> Send for SafePtr<T> {}
unsafe impl<T> Sync for SafePtr<T> {}

// 测试：跨线程共享 SafePtr
fn main() {
    let ptr = SafePtr::new(5);
    let ptr_clone = Arc::new(ptr);
    let ptr_clone2 = ptr_clone.clone();

    thread::spawn(move || {
        println!("线程内访问：{}", ptr_clone2.get().unwrap()); // 安全
    }).join().unwrap();
}