Rust try 实现线程安全的缓存

关于你问题的第二部分(将读锁升级为写锁)，我只是在获得写锁之前先删除读锁.:-(

但是，关于第一部分(在此哈希映射发生Mutations 时返回对哈希映射内容的引用)，我有一个线索.

在这种情况下，引用的元素基本上是共享的，所有权不仅仅是缓存本身的问题. 例如，如果我们决定在流程中的某个点清除缓存，则不能删除仍被引用的元素. 因此，我们需要为缓存中的每个值共享所有权. 如果需要，我们需要存储Arc<Value>，而不是存储Value，以便使该值比缓存更持久.

请在下面找到针对过于简单的情况(无泛型类型，硬编码示例)实现此功能的try :将一个字符串与其字符的代码向量相关联. 串行实现依赖于RefCell和Rc，而并行实现依赖于它们的同步类似功能RwLock和Arc. 在每个DEMO中，我们可以看到，当同一个字符串用于多次读取(向量被缓存)时，获取的Slice的地址保持不变.

mod serial {
    use std::{cell::RefCell, collections::HashMap, rc::Rc};

    pub struct Cache {
        data: RefCell<HashMap<String, Rc<Vec<u32>>>>,
    }

    impl Cache {
        pub fn new() -> Self {
            Self {
                data: RefCell::new(HashMap::new()),
            }
        }

        pub fn fetch(
            &self,
            key: &str,
        ) -> Rc<Vec<u32>> {
            if let Some(v) = self.data.borrow().get(key) {
                return Rc::clone(v);
            }
            let k = key.to_owned();
            let v = Rc::new(key.chars().map(|c| c as u32).collect());
            self.data.borrow_mut().insert(k, Rc::clone(&v));
            v
        }
    }

    pub fn demo() {
        println!("~~~~ serial demo ~~~~");
        let cache = Cache::new();
        for key in ["abc", "def", "ghi"] {
            for it in 0..2 {
                let v = cache.fetch(key);
                println!("iter {}: {:?} @ {:?}", it, v, v.as_ptr());
            }
        }
    }
}

mod parallel {
    use std::{collections::HashMap, sync::Arc, sync::RwLock};

    pub struct Cache {
        data: RwLock<HashMap<String, Arc<Vec<u32>>>>,
    }

    impl Cache {
        pub fn new() -> Self {
            Self {
                data: RwLock::new(HashMap::new()),
            }
        }

        pub fn fetch(
            &self,
            key: &str,
        ) -> Arc<Vec<u32>> {
            if let Some(v) = self.data.read().unwrap().get(key) {
                return Arc::clone(v);
            }
            let k = key.to_owned();
            let v = Arc::new(key.chars().map(|c| c as u32).collect());
            self.data.write().unwrap().insert(k, Arc::clone(&v));
            v
        }
    }

    pub fn demo() {
        println!("~~~~ parallel demo ~~~~");
        let cache = Cache::new();
        std::thread::scope(|s| {
            for it in 0..2 {
                s.spawn({
                    let cache = &cache;
                    move || {
                        for key in ["abc", "def", "ghi"] {
                            std::thread::yield_now();
                            let v = cache.fetch(key);
                            println!(
                                "thread {}: {:?} @ {:?}",
                                it,
                                v,
                                v.as_ptr()
                            );
                        }
                    }
                });
            }
        });
    }
}

fn main() {
    serial::demo();
    parallel::demo();
}
/*
~~~~ serial demo ~~~~
iter 0: [97, 98, 99] @ 0x557c23797bc0
iter 1: [97, 98, 99] @ 0x557c23797bc0
iter 0: [100, 101, 102] @ 0x557c23797c00
iter 1: [100, 101, 102] @ 0x557c23797c00
iter 0: [103, 104, 105] @ 0x557c23797c40
iter 1: [103, 104, 105] @ 0x557c23797c40
~~~~ parallel demo ~~~~
thread 1: [97, 98, 99] @ 0x7ff378000cc0
thread 0: [97, 98, 99] @ 0x7ff378000cc0
thread 1: [100, 101, 102] @ 0x7ff378000d00
thread 0: [100, 101, 102] @ 0x7ff378000d00
thread 1: [103, 104, 105] @ 0x7ff378000d40
thread 0: [103, 104, 105] @ 0x7ff378000d40
*/