Send 与 Sync 含义 ​

面试题 ​

请解释 Rust 中 Send 和 Sync trait 的含义,它们是如何在编译期保证线程安全的?

考察意图 ​

Send 和 Sync 是 Rust 并发安全的基石。面试官想看候选人能否清晰区分两者的语义——Send 关于所有权转移,Sync 关于共享引用——以及编译器如何利用它们在编译期排除数据竞争。

答题要点 ​

Send 和 Sync 的定义 ​

rust
// 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 实现 ​

类型SendSync原因
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 的作用 ​

rust
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 的作用 ​

rust
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 ​

rust
// 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 ​

rust
// 极少数情况下需要手动实现 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 检查不是线程安全的。

基本示例 ​

rust
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。