如何在Rust中实现n+1线程的单写多读访问控制？

你的场景正好适合用Arc<RwLock<T>>组合，比Arc<Mutex<T>>更高效——因为Mutex是独占锁，不管读写都得排队，而RwLock支持多个读线程同时访问，同一时间只能有一个写线程持有锁，完美匹配你单写多读的需求。

核心原理 #

• Arc：原子引用计数智能指针，让多个线程能安全共享同一个数据的所有权，线程间cloneArc只会增加引用计数，不会复制底层数据。
• RwLock：读写锁，提供两种锁定方式：
  • read()：获取读锁，允许多个线程同时持有，只要没有写锁被持有。
  • write()：获取写锁，同一时间只能有一个线程持有，且会阻塞所有读/写请求直到锁释放。

完整代码示例 #

假设我们要共享的数据是一个简单的计数器：

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

// 定义共享数据结构
#[derive(Debug)]
struct SharedData {
    counter: u32,
}

fn main() {
    // 创建Arc包裹的RwLock，初始化共享数据
    let shared_data = Arc::new(RwLock::new(SharedData { counter: 0 }));
    let n = 5; // 读线程数量

    // 启动写线程
    let write_data = Arc::clone(&shared_data);
    thread::spawn(move || {
        for i in 0..10 {
            // 获取写锁，修改数据
            let mut data = write_data.write().unwrap();
            data.counter += 1;
            println!("写线程更新计数器: {}", data.counter);
            drop(data); // 手动释放锁（也可以等作用域结束自动释放）
            thread::sleep(Duration::from_millis(500));
        }
    });

    // 启动n个读线程
    for i in 0..n {
        let read_data = Arc::clone(&shared_data);
        thread::spawn(move || {
            loop {
                // 获取读锁，读取数据
                let data = read_data.read().unwrap();
                println!("读线程{}读取计数器: {}", i, data.counter);
                drop(data);
                thread::sleep(Duration::from_millis(300));
            }
        });
    }

    // 让主线程保持运行，避免提前退出
    thread::sleep(Duration::from_secs(10));
}

关键细节说明 #

1. 锁的释放：锁会在离开作用域时自动释放，不过手动调用drop(data)可以提前释放锁，提升并发效率。
2. PoisonError处理：示例中用unwrap()简化处理，实际生产环境中可以根据需求处理PoisonError——当持有锁的线程panic时，锁会进入“中毒”状态，此时可以选择恢复数据或者终止程序。
3. 为什么不用Mutex：如果用Arc<Mutex<T>>，每个读线程都要独占锁，读操作会互相阻塞，完全发挥不出多线程读的优势，效率远低于RwLock。

内容的提问来源于stack exchange，提问作者dnnagy