Rust专项——并发前置：Send/Sync 与共享数据设计

红目香薰

发布于 2025-12-16 16:22:14

1290

文章被收录于专栏：CSDNToQQCodeCSDNToQQCode

本篇作为进入并发编程之前的地基，讲清楚两个关键自动 trait：Send 和 Sync，以及在多线程下如何安全地共享和修改数据。包含 Arc、Mutex、RwLock、消息通道（channel）与常见陷阱。

1. Send 与 Sync 是什么？

Send：类型的所有权可以在线程间转移（move）。绝大多数标准类型都是 Send。
Sync：如果 T: Sync，则 &T 可以在多个线程间共享（即 &T 是 Send）。
直觉：Send 关乎“能否把值交给另一个线程”；Sync 关乎“能否把不可变引用同时给多个线程用”。

常见：

i32, String, Vec<T>：Send。
&T：当且仅当 T: Sync 时，&T: Send。
Rc<T>：非线程安全（不是 Send/Sync）；Arc<T>：线程安全引用计数。
Cell<T>/RefCell<T>：非 Sync，仅单线程；Mutex<T>/RwLock<T>：Sync，用于并发。

2. 在线程间共享所有权：Arc

use std::sync::Arc;
use std::thread;

fn main() {
    let data = Arc::new(vec![1,2,3]);
    let mut handles = vec![];

    for _ in 0..4 {
        let shared = Arc::clone(&data); // 增加引用计数
        handles.push(thread::spawn(move || {
            // 只读共享：无需加锁
            shared.iter().sum::<i32>()
        }));
    }

    let total: i32 = handles.into_iter().map(|h| h.join().unwrap()).sum();
    println!("sum = {}", total);
}

结论：只读共享用 Arc<T> 即可；若需写，则配合锁。

3. 可变共享：Mutex 与 RwLock

Mutex<T>：互斥锁，独占写；
RwLock<T>：读写锁，多读一写；
两者都需要与 Arc 搭配才能跨线程共享所有权。

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

fn main() {
    let counter = Arc::new(Mutex::new(0u64));
    let mut handles = vec![];

    for _ in 0..8 {
        let c = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            for _ in 0..100_000 {
                *c.lock().unwrap() += 1; // 临界区
            }
        }));
    }

    for h in handles { h.join().unwrap(); }
    println!("count = {}", *counter.lock().unwrap());
}

要点：

lock() 返回 MutexGuard<T>，实现了 DerefMut，出作用域自动解锁。
避免把锁守卫长期持有（缩小作用域），减少死锁风险。

RwLock 示例：

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

fn main() {
    let store = Arc::new(RwLock::new(Vec::<u32>::new()));

    // 写入线程
    {
        let s = Arc::clone(&store);
        std::thread::spawn(move || {
            for i in 0..10 { s.write().unwrap().push(i); }
        });
    }

    // 读取线程
    {
        let s = Arc::clone(&store);
        std::thread::spawn(move || {
            loop {
                let snapshot = s.read().unwrap().clone(); // 短暂持锁，尽快释放
                if snapshot.len() >= 10 { break; }
            }
        });
    }
}

4. 消息传递：无共享更简单

相比共享可变状态，“消息传递”往往更简单更安全：

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel::<String>();

    thread::spawn(move || {
        for i in 0..3 {
            tx.send(format!("msg-{i}")).unwrap();
            thread::sleep(Duration::from_millis(50));
        }
    });

    for received in rx { println!("got: {}", received); }
}

mpsc：多生产者、单消费者。
若需要多消费者，可用跨端库或 broadcast 模式（如 tokio::sync）。

5. Rc/RefCell 在多线程中的坑

Rc<T> 与 RefCell<T> 并非线程安全：不实现 Send/Sync。
多线程请改用 Arc<T> 与 Mutex<T>/RwLock<T>。
在单线程异步中（如 GUI）Rc<RefCell<T>> 仍然非常好用，但请清晰限定单线程语境。

6. 组合范式：Arc + Mutex + Channel

Arc<Mutex<T>> 共享可变数据；
mpsc 通知与任务派发；
线程之间只传消息或轻量句柄，避免传整个大对象。

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

fn main() {
    let state = Arc::new(Mutex::new(0usize));
    let (tx, rx) = mpsc::channel::<usize>();

    // worker
    {
        let st = Arc::clone(&state);
        thread::spawn(move || {
            for job in rx { *st.lock().unwrap() += job; }
        });
    }

    // dispatcher
    for n in [1,2,3,4,5] { tx.send(n).unwrap(); }
    drop(tx); // 关闭通道，结束 worker 循环

    // 等待片刻或 join 线程（示意）
    std::thread::sleep(std::time::Duration::from_millis(10));
    println!("final = {}", *state.lock().unwrap());
}