Rust中如何从Entry获取HashMap？缓存实现的借用检查问题

你在实现缓存时遇到了借用检查器的限制：先用Entry查找缓存，命中则返回；未命中时对特定值用简单方法生成；如果都不满足，就批量计算并插入多个条目。但Entry的借用会持续到整个函数的生命周期'a，导致后续的insert操作无法通过检查。

先看你的原代码：

use std::collections::HashMap;
fn main() {
    let mut cache = Cache { cache: HashMap::new() };
    println!("{}", cache.get_from_cache(10));

}


struct Cache {
    cache: HashMap<u32, String>
}
impl Cache {
    fn get_from_cache<'a>(&'a mut self, i: u32) -> &'a String {
        match self.cache.entry(i) {
            std::collections::hash_map::Entry::Occupied(entry) => return entry.into_mut(),
            std::collections::hash_map::Entry::Vacant(entry) => {
                // Some values have an easy way to be computed...
                if i == 5 {
                    return entry.insert("my string".to_string())
                }
            }
        }

        // Neither look-up method succeeded, so we 'compute' values one-by-one
        for j in 1..=i {
            self.cache.insert(j, "another string".to_string()); // Borrow checker fails here
        }
        self.cache.get(&i).unwrap()
        
    }
    
}

问题根源在于，entry方法返回的Entry结构体持有了self.cache的可变借用，而match语句的作用域和函数的'a生命周期绑定，编译器认为这个借用会一直持续到函数结束，所以后面的insert操作无法再次获取可变借用。

解决方案一：拆分逻辑，提前检查存在性 #

放弃一开始就用Entry，先通过get检查缓存是否存在，再处理特殊值的生成，最后执行批量插入。这样每个阶段的借用都是独立的，不会互相干扰：

use std::collections::HashMap;

fn main() {
    let mut cache = Cache { cache: HashMap::new() };
    println!("{}", cache.get_from_cache(10));
}

struct Cache {
    cache: HashMap<u32, String>
}

impl Cache {
    fn get_from_cache<'a>(&'a mut self, i: u32) -> &'a String {
        // 先检查缓存是否存在，直接返回已有值
        if let Some(val) = self.cache.get(&i) {
            return val;
        }

        // 处理特殊值的简单生成逻辑
        if i == 5 {
            self.cache.insert(i, "my string".to_string());
            return self.cache.get(&i).unwrap();
        }

        // 批量生成并插入缓存条目
        for j in 1..=i {
            self.cache.insert(j, "another string".to_string());
        }
        self.cache.get(&i).unwrap()
    }
}

解决方案二：限制Entry的借用作用域 #

如果想保留Entry的使用，可以把Entry的match语句包裹在一个单独的代码块中。代码块结束后，Entry持有的借用会被自动释放，后续的insert操作就能正常获取可变借用：

use std::collections::HashMap;

fn main() {
    let mut cache = Cache { cache: HashMap::new() };
    println!("{}", cache.get_from_cache(10));
}

struct Cache {
    cache: HashMap<u32, String>
}

impl Cache {
    fn get_from_cache<'a>(&'a mut self, i: u32) -> &'a String {
        // 用代码块限制Entry的借用范围
        {
            match self.cache.entry(i) {
                std::collections::hash_map::Entry::Occupied(entry) => return entry.into_mut(),
                std::collections::hash_map::Entry::Vacant(entry) => {
                    if i == 5 {
                        return entry.insert("my string".to_string());
                    }
                    // 非特殊值的Vacant情况不处理，代码块结束后借用释放
                }
            }
        }

        // 批量插入新条目
        for j in 1..=i {
            self.cache.insert(j, "another string".to_string());
        }
        self.cache.get(&i).unwrap()
    }
}

两种方案都能解决借用检查器的问题，第一种逻辑更直观，适合大多数场景；第二种保留了Entry的使用，适合需要利用Entry原子性特性的场景。

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