如何在Rust的阻塞函数与异步函数之间共享HashMap

嘿，针对你要做类似Redis过期键清理的场景，我来给你好好讲讲怎么在Rust的阻塞和异步函数之间安全共享HashMap～

首先，核心思路是用原子引用计数（Arc）搭配线程安全的锁，因为不管是异步任务还是普通的阻塞线程，跨线程共享数据必须保证线程安全。这里有两种常用的组合，你可以根据自己的场景选：

1. 用Arc<Mutex<HashMap<...>>>：通用场景首选 #

Arc能让多个线程共享同一个HashMap的所有权，而Mutex能保证同一时间只有一个线程能访问HashMap——不管是异步函数里的读写操作，还是后台阻塞线程的清理工作，都能安全执行。

举个贴合你场景的小例子：

use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::{Duration, Instant};
use tokio;

// 定义我们的共享HashMap类型：键是字符串，值存（实际内容+过期时间）
type SharedExpiryMap = Arc<Mutex<HashMap<String, (String, Instant)>>>;

#[tokio::main]
async fn main() {
    // 初始化共享的HashMap
    let shared_map: SharedExpiryMap = Arc::new(Mutex::new(HashMap::new()));

    // 启动异步任务模拟Redis的请求处理（比如接收set命令）
    let async_map_clone = Arc::clone(&shared_map);
    tokio::spawn(async move {
        loop {
            // 拿到锁，操作HashMap
            let mut map = async_map_clone.lock().expect("锁被异常持有");
            // 插入一个10秒后过期的键值对
            map.insert(
                "user:1001".to_string(),
                ("Alice".to_string(), Instant::now() + Duration::from_secs(10))
            );
            // 提前释放锁，别占着资源影响其他操作
            drop(map);
            // 模拟每秒处理一次请求
            tokio::time::sleep(Duration::from_secs(1)).await;
        }
    });

    // 启动普通阻塞线程做过期键清理（长睡眠用普通线程更合适，不占tokio的线程池）
    let cleanup_map_clone = Arc::clone(&shared_map);
    thread::spawn(move || {
        loop {
            // 每隔5秒检查一次过期键
            thread::sleep(Duration::from_secs(5));
            let mut map = cleanup_map_clone.lock().expect("锁被异常持有");
            // 过滤掉已过期的键
            map.retain(|_, (_, expire_time)| expire_time > &Instant::now());
            println!("清理完成，当前剩余有效键数: {}", map.len());
        }
    });

    // 让主线程一直运行，别提前退出
    loop {
        thread::sleep(Duration::from_secs(60));
    }
}

2. 用Arc<RwLock<HashMap<...>>>：读多写少场景更高效 #

如果你的场景和Redis类似，大部分是读操作、很少写或者清理操作，那用RwLock会比Mutex更高效——因为RwLock允许同时有多个线程读数据，只有在写操作（比如插入键、删除过期键）的时候才会互斥。

用法和Mutex差不多，只是读的时候用read()，写的时候用write()：

// 定义RwLock版本的共享Map
type SharedExpiryMap = Arc<RwLock<HashMap<String, (String, Instant)>>>;

// 异步里读操作示例
let map = shared_map.read().expect("读锁异常");
if let Some((val, _)) = map.get("user:1001") {
    println!("查到值: {}", val);
}
drop(map);

// 后台清理线程里的写操作
let mut map = shared_map.write().expect("写锁异常");
map.retain(|_, (_, expire_time)| expire_time > &Instant::now());

几个要注意的小细节 #

• 锁的持有时间越短越好：比如在异步任务里，拿到锁后赶紧完成操作就释放，别在锁持有期间做await或者其他长时间阻塞的事，不然会影响tokio的调度效率。
• 别直接用unwrap()：上面的示例为了简洁用了expect，实际项目里要好好处理PoisonError——比如当持有锁的线程panic时，锁会进入“中毒”状态，这时候需要用into_inner()来恢复数据。
• 异步锁的坑：如果你平时用tokio的tokio::sync::Mutex，要注意它是针对异步调度优化的，普通阻塞线程里用起来很麻烦（需要套tokio::runtime::Runtime::new().unwrap().block_on(...)），所以跨阻塞和异步的场景，用标准库的std::sync::Mutex/RwLock反而更适配。

备注：内容来源于stack exchange，提问作者ivanbgd