Rust 2026 经验谈 - Send/Sync 深度理解

1
use std::sync::Arc;
2
use std::marker::PhantomData;
3

4
// 例 1：含 PhantomData 的推导
5
struct MyType<T> {
6
    _marker: PhantomData<T>,
7
    data: Vec<u8>,
8
}
9

10
// MyType<T>: Send 当且仅当 T: Send
11
// MyType<T>: Sync 当且仅当 T: Sync
12
// 因为 PhantomData<T> 的 Send/Sync 与 T 一致
13

14
// 例 2：裸指针的推导
15
struct WithRawPtr {
16
    ptr: *const i32,  // *const T 不是 Send 也不是 Sync
17
}
18

19
// WithRawPtr 自动不是 Send 也不是 Sync
20

21
// 例 3：Arc 的推导
22
// Arc<T>: Send 当且仅当 T: Send + Sync
23
// Arc<T>: Sync 当且仅当 T: Send + Sync
24
// 因为 Arc 的引用计数是原子操作（Send + Sync），
25
// 但内部的 T 需要能被多个线程访问（Sync）且能被发送（Send）

1
use std::sync::Mutex;
2
use std::rc::Rc;
3

4
struct ThreadSafeRc {
5
    inner: Mutex<Rc<i32>>,  // Rc 不是 Send 也不是 Sync
6
}
7

8
// 安全论证：
9
// 1. Rc 被锁在 Mutex 内部
10
// 2. 任何时刻只有一个线程能通过 lock() 访问 Rc
11
// 3. Rc 不会跨线程转移（在锁内使用）
12
// 4. 因此 ThreadSafeRc 可以安全地跨线程共享
13

14
unsafe impl Send for ThreadSafeRc {}
15
unsafe impl Sync for ThreadSafeRc {}

1
use std::ffi::c_void;
2

3
// C 库声明的不透明类型
4
#[repr(C)]
5
pub struct FfiContext {
6
    _private: [u8; 0],
7
}
8

9
// C 库的函数声明
10
unsafe extern "C" {
11
    fn ffi_context_new() -> *mut FfiContext;
12
    fn ffi_context_process(ctx: *mut FfiContext, data: *const c_void, len: usize) -> i32;
13
    fn ffi_context_free(ctx: *mut FfiContext);
14
}
15

16
// 如果 C 库文档说 FfiContext 可以在多线程中使用：
17
unsafe impl Send for FfiContext {}
18
unsafe impl Sync for FfiContext {}
19

20
// 如果 C 库文档说 FfiContext 不是线程安全的：
21
// 什么都不 impl——保持非 Send 非 Sync

1
// 错误 1：为含 Rc 的类型盲目 impl Send
2
struct Bad {
3
    rc: std::rc::Rc<Vec<i32>>,
4
}
5
unsafe impl Send for Bad {}  // 未定义行为！Rc 的引用计数不是原子操作
6

7
// 错误 2：为含 Cell 的类型盲目 impl Sync
8
struct AlsoBad {
9
    cell: std::cell::Cell<i32>,
10
}
11
unsafe impl Sync for AlsoBad {}  // 未定义行为！Cell 无同步，多线程写入是数据竞争
12

13
// 正确的做法：用 Mutex 包装
14
struct Good {
15
    inner: Mutex<std::cell::Cell<i32>>,
16
}
17
unsafe impl Send for Good {}  // 安全：Cell 被锁保护
18
unsafe impl Sync for Good {}  // 安全：同上

1
use std::sync::{Arc, Mutex};
2

3
// 模式 A：Arc<Mutex<T>>——需要修改
4
let shared_data: Arc<Mutex<Vec<i32>>> = Arc::new(Mutex::new(vec![]));
5

6
// 多个线程修改同一数据
7
let mut handles = vec![];
8
for i in 0..4 {
9
    let data = shared_data.clone();
10
    handles.push(std::thread::spawn(move || {
11
        let mut guard = data.lock().unwrap();
12
        guard.push(i);
13
    }));
14
}
15

16
// 模式 B：Arc<T> where T: Sync——只读共享
17
let shared_config: Arc<Vec<String>> = Arc::new(vec![
18
    "config1".to_owned(),
19
    "config2".to_owned(),
20
]);
21

22
// 多个线程只读同一数据
23
for i in 0..4 {
24
    let config = shared_config.clone();
25
    std::thread::spawn(move || {
26
        // 无需加锁，直接读取
27
        println!("线程 {i} 读取: {:?}", *config);
28
    });
29
}

1
use std::thread;
2

3
fn parallel_process(data: &[i32]) -> Vec<i32> {
4
    let mut results = vec![0; data.len()];
5

6
    thread::scope(|s| {
7
        // 分片处理，无需 Arc
8
        let chunk_size = (data.len() + 3) / 4;
9
        for (i, chunk) in data.chunks(chunk_size).enumerate() {
10
            let result_slice = &mut results[i * chunk_size..][..chunk.len()];
11
            s.spawn(move || {
12
                for (j, &val) in chunk.iter().enumerate() {
13
                    result_slice[j] = val * 2;
14
                }
15
            });
16
        }
17
    });
18

19
    results
20
}

1
use dashmap::DashMap;
2
use std::sync::Arc;
3

4
fn concurrent_map() {
5
    let map: Arc<DashMap<String, i32>> = Arc::new(DashMap::new());
6

7
    // DashMap 内部分片，减少锁竞争
8
    let mut handles = vec![];
9
    for i in 0..8 {
10
        let map = map.clone();
11
        handles.push(std::thread::spawn(move || {
12
            map.insert(format!("key-{i}"), i);
13
            if let Some(v) = map.get(&format!("key-{}", i % 4)) {
14
                println!("读取: {}", *v);
15
            }
16
        }));
17
    }
18

19
    for h in handles {
20
        h.join().unwrap();
21
    }
22
}

1
use std::sync::OnceLock;
2
use std::sync::Arc;
3

4
static GLOBAL_CONFIG: OnceLock<Arc<Config>> = OnceLock::new();
5

6
struct Config {
7
    db_url: String,
8
    max_connections: usize,
9
}
10

11
fn get_config() -> &'static Arc<Config> {
12
    GLOBAL_CONFIG.get_or_init(|| {
13
        Arc::new(Config {
14
            db_url: "postgres://localhost".to_owned(),
15
            max_connections: 10,
16
        })
17
    })
18
}
19

20
// 任何线程调用 get_config() 都是安全的
21
// 第一次调用初始化，后续调用返回已有值

1
use std::sync::Arc;
2

3
// 约束太松：可能编译失败
4
fn spawn_task<T>(data: Arc<T>) {
5
    // tokio::spawn 要求 Future 是 Send
6
    // 但 Arc<T> 的 Send 需要 T: Send + Sync
7
    // 如果 T 只满足 Send 但不满足 Sync，这里会出错
8
}
9

10
// 约束精确
11
fn spawn_task_correct<T: Send + Sync + 'static>(data: Arc<T>) {
12
    tokio::spawn(async move {
13
        // 现在 Arc<T> 确定是 Send
14
        let _ = &*data;
15
    });
16
}
17

18
// 另一种模式：不需要 Arc，直接传 T
19
fn spawn_with_value<T: Send + 'static>(data: T) {
20
    tokio::spawn(async move {
21
        // T 转移到新线程，只需 Send
22
        let _ = &data;
23
    });
24
}