Rust中HashMap可变与不可变借用冲突问题求解

问题描述 #

我定义了如下的struct Node和node_map：

pub struct Node<'a> {
    id: i32,
    next: HashMap<String, &'a Node<'a>>,
}

let mut node_map = HashMap::<i32, Node>::new();

在使用node_map时，我先通过get_mut获取可变的node，随后在循环中尝试获取neighbour的不可变引用并插入到node.next中：

let Some(node) = node_map.get_mut(&node_id) else {
    return Err("无效的node_id".to_string());
};

// 一些获取edge_pairs的逻辑
for pair in edge_pairs {
    // 一些获取neighbour_id的逻辑

    let Some(neighbour) = node_map.get(&neighbour_id) else {
        return Err("无效的node_id".to_string());
    };

    node.next.insert(char.to_string(), neighbour);
}

此时出现错误：

cannot borrow node_map as immutable because it is also borrowed as mutable
immutable borrow occurs here [E0502]

我需要node保持可变以插入新值，同时neighbour为不可变引用，不想使用clone，希望保留节点引用，该如何解决这个问题？

解决方案 #

方法1：先收集邻居引用，再统一插入

核心逻辑是先完成所有邻居的不可变引用收集，释放对node_map的不可变借用后，再获取可变节点执行插入操作，从根源上避免同时存在可变和不可变借用的冲突。

示例代码：

// 先遍历edge_pairs，收集所有需要的邻居引用
let mut neighbour_entries = Vec::new();
for pair in &edge_pairs {
    // 这里写获取neighbour_id的逻辑
    let Some(neighbour) = node_map.get(&neighbour_id) else {
        return Err("无效的node_id".to_string());
    };
    neighbour_entries.push((char.to_string(), neighbour));
}

// 再获取可变节点，插入收集好的邻居
let Some(node) = node_map.get_mut(&node_id) else {
    return Err("无效的node_id".to_string());
};

for (key, neighbour) in neighbour_entries {
    node.next.insert(key, neighbour);
}

方法2：用RefCell实现内部可变性

如果无法调整操作顺序，可以通过RefCell将Node的next字段改为内部可变类型。这样只需持有节点的不可变引用，就能通过RefCell的运行时检查修改next，避免全局的可变借用冲突。

修改结构体定义：

use std::cell::RefCell;

pub struct Node<'a> {
    id: i32,
    next: RefCell<HashMap<String, &'a Node<'a>>>,
}

使用代码：

// 获取节点的不可变引用
let Some(node) = node_map.get(&node_id) else {
    return Err("无效的node_id".to_string());
};

for pair in edge_pairs {
    let Some(neighbour) = node_map.get(&neighbour_id) else {
        return Err("无效的node_id".to_string());
    };
    // 通过RefCell获取可变权限插入数据
    node.next.borrow_mut().insert(char.to_string(), neighbour);
}

方法3：存储邻居ID而非引用

如果允许调整结构体设计，可以将next中存储的内容改为邻居的id，彻底规避生命周期和借用冲突问题。后续需要访问邻居时，直接通过node_map根据ID查找即可。

修改结构体定义：

pub struct Node {
    id: i32,
    next: HashMap<String, i32>,
}

使用代码：

let Some(node) = node_map.get_mut(&node_id) else {
    return Err("无效的node_id".to_string());
};

for pair in edge_pairs {
    // 先验证邻居ID存在
    if node_map.get(&neighbour_id).is_none() {
        return Err("无效的node_id".to_string());
    }
    node.next.insert(char.to_string(), neighbour_id);
}

方法对比 #

• 方法1：完全遵循Rust静态借用规则，无额外性能开销，优先推荐用于能调整操作顺序的场景。
• 方法2：适合无法调整流程的场景，但会引入运行时借用检查开销，需注意避免同时持有多个可变借用导致的panic。
• 方法3：彻底消除生命周期复杂度，结构更简洁，适合允许间接查找邻居的场景。

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