如何在不锁定整个HashMap的情况下实现多线程共享？

你遇到的核心问题其实是不该把整个结构体用Mutex包裹——这样哪怕HashMap里的每个值都加了锁，也得先拿到整个结构体的锁才能操作，完全抵消了细粒度锁的作用。咱们来拆解场景，给出两种可行的实现方案：

场景1：HashMap的Key集合固定，仅更新Value #

如果你的HashMap不会新增/删除Key，只是修改已有Key对应的Value，那可以把HashMap本身用Arc包裹（因为结构不变，只读状态下是线程安全的），每个Value用Mutex保护。只读字段直接放在结构体里就行，因为永不修改，多线程读取完全安全：

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

struct S {
    // 永不修改的只读字段，直接放在结构体中
    readonly_id: u32,
    readonly_name: &'static str,
    // 结构固定的HashMap，每个Value用Mutex保护
    data_map: Arc<HashMap<u8, Mutex<u8>>>,
}

impl S {
    pub fn new() -> Self {
        let mut map = HashMap::new();
        // 初始化固定的Key集合
        map.insert(1, Mutex::new(10));
        map.insert(2, Mutex::new(20));
        
        S {
            readonly_id: 1001,
            readonly_name: "shared_struct",
            data_map: Arc::new(map),
        }
    }
}

fn main() {
    let shared_s = Arc::new(S::new());

    // 线程1更新Key=1的Value
    let s_clone1 = shared_s.clone();
    thread::spawn(move || {
        if let Some(val_mutex) = s_clone1.data_map.get(&1) {
            let mut val = val_mutex.lock().unwrap();
            *val += 5;
            println!("线程1更新后，Key=1的值：{}", val);
        }
    });

    // 线程2更新Key=2的Value，不会被线程1阻塞
    let s_clone2 = shared_s.clone();
    thread::spawn(move || {
        if let Some(val_mutex) = s_clone2.data_map.get(&2) {
            let mut val = val_mutex.lock().unwrap();
            *val *= 2;
            println!("线程2更新后，Key=2的值：{}", val);
        }
    });

    thread::sleep(std::time::Duration::from_secs(1));
}

这种方案下，多个线程可以同时操作不同的Key，只有操作同一个Key时才会互斥，完全达到了细粒度锁的效果。

场景2：需要动态新增/删除HashMap的Key #

如果你的HashMap需要动态修改Key集合（插入/删除），那HashMap本身的结构会变化，必须用RwLock来保护它（读操作共享锁，写操作独占锁），同时每个Value依然用Mutex保护：

use std::collections::HashMap;
use std::sync::{Arc, Mutex, RwLock};
use std::thread;

struct S {
    readonly_field: u32,
    // 用RwLock保护HashMap，支持多线程读取、独占写入
    data_map: Arc<RwLock<HashMap<u8, Mutex<u8>>>>,
}

impl S {
    pub fn new() -> Self {
        S {
            readonly_field: 42,
            data_map: Arc::new(RwLock::new(HashMap::new())),
        }
    }

    // 插入新的Key-Value（需要独占写锁）
    pub fn insert(&self, key: u8, val: u8) {
        let mut map = self.data_map.write().unwrap();
        map.insert(key, Mutex::new(val));
        println!("插入Key={}，初始值={}", key, val);
    }

    // 更新已有Key的Value（仅需共享读锁，再锁对应Value）
    pub fn update(&self, key: u8, delta: u8) -> Option<u8> {
        let map = self.data_map.read().unwrap();
        map.get(&key).map(|val_mutex| {
            let mut val = val_mutex.lock().unwrap();
            *val += delta;
            *val
        })
    }
}

fn main() {
    let shared_s = Arc::new(S::new());

    // 线程1插入新Key
    let s_clone1 = shared_s.clone();
    thread::spawn(move || {
        s_clone1.insert(3, 30);
    });

    // 线程2等待插入完成后更新Key=3的值
    let s_clone2 = shared_s.clone();
    thread::spawn(move || {
        thread::sleep(std::time::Duration::from_millis(500));
        if let Some(new_val) = s_clone2.update(3, 10) {
            println!("线程2更新后，Key=3的值：{}", new_val);
        }
    });

    thread::sleep(std::time::Duration::from_secs(1));
}

这种方案下，大部分时候的更新操作只需要获取共享读锁，多个线程可以同时操作不同的Key；只有插入/删除Key时才会触发独占锁，对性能的影响很小。

关键知识点回顾 #

Rust的线程安全依赖Send和Synctrait：

• 只读字段因为永不修改，天然满足Sync，直接放在Arc包裹的结构体里即可共享。
• HashMap本身不是Sync的，所以需要用RwLock或Mutex包裹来实现线程安全；而Mutex<u8>是Send+Sync的，所以可以安全地放在HashMap中。

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