Rust中返回&RefCell引发多次可变借用错误的解决方法咨询

我正在尝试实现一个父对象，用于创建并管理子对象。该父对象通过工厂函数返回&RefCell<Child>，以便后续借用子对象。我将代码精简为以下示例：

use std::{collections::HashMap, cell::RefCell, error::Error};

struct Child(i32);

impl Child {
    pub fn new(id: i32) -> Child {
        Child(id)
    }
}

struct Parent {
    children: HashMap<i32, Box<RefCell<Child>>>,
}

impl Parent {
    pub fn new() -> Parent {
        Parent {
            children: HashMap::new(),
        }
    }

    pub fn create_child(&mut self, id: i32) -> &RefCell<Child> {
        let child = Child::new(id);
        let cell = Box::new(RefCell::new(child));
        self.children.insert(id, cell);
        return self.children.get(&id).unwrap();
    }

    pub fn beep(&mut self) {}
}

fn main() {
    let mut parent = Parent::new();
    let child1 = parent.create_child(1);
    let child2 = parent.create_child(2);
    child1.borrow();
}

但当我尝试借用子对象的引用时，出现了如下编译错误：

error[E0499]: cannot borrow `parent` as mutable more than once at a time
 --> foo\src\main.rs:37:18
|
36 | let child1 = parent.create_child(1);
| ---------------------- first mutable borrow occurs here
37 | let child2 = parent.create_child(2);
| ^^^^^^^^^^^^^^^^^^^^^^ second mutable borrow occurs here
38 | child1.borrow();
| --------------- first borrow later used here

请问是否存在一种方法，能够返回&RefCell同时避免该错误？

这是典型的Rust借用检查器静态约束问题，我来帮你拆解原因和可行的解决思路：

问题根源 #

当你调用create_child时，函数需要&mut self，这意味着它会获取Parent的可变借用。而你返回的&RefCell<Child>是直接指向Parent内部HashMap中的元素，Rust的借用检查器会认为这个引用的生命周期和Parent的可变绑定绑定在一起——只要这个引用还活着，Parent就不能被再次可变借用，否则可能导致引用失效（比如HashMap扩容会移动元素位置）。

下面是几种可行的解决方式：

1. 调整操作顺序（最简单的临时方案） #

如果你的业务逻辑允许，可以先完成所有子对象的创建操作，再去获取并使用子对象的引用：

fn main() {
    let mut parent = Parent::new();
    // 先完成所有需要可变Parent的操作
    parent.create_child(1);
    parent.create_child(2);
    
    // 现在只需要不可变借用Parent来获取子对象引用
    let child1 = parent.children.get(&1).unwrap();
    let child2 = parent.children.get(&2).unwrap();
    
    child1.borrow();
}

这种方式不需要修改Parent的结构，但缺点是不够灵活——如果需要在创建子对象后立即使用它，就无法满足需求。

2. 将Parent的内部状态包裹在RefCell中（保持返回引用的形式） #

我们可以把Parent的children字段放到RefCell里，这样create_child只需要&self（不可变引用）就能修改内部状态，避免了多次可变借用的冲突：

use std::{collections::HashMap, cell::RefCell, error::Error};

struct Child(i32);

impl Child {
    pub fn new(id: i32) -> Child {
        Child(id)
    }
}

struct Parent {
    // 把HashMap包裹在RefCell中，转移内部可变性
    children: RefCell<HashMap<i32, Box<RefCell<Child>>>>,
}

impl Parent {
    pub fn new() -> Parent {
        Parent {
            children: RefCell::new(HashMap::new()),
        }
    }

    // 现在只需要&self即可
    pub fn create_child(&self, id: i32) -> &RefCell<Child> {
        let mut children = self.children.borrow_mut();
        let child = Child::new(id);
        let cell = Box::new(RefCell::new(child));
        children.insert(id, cell);
        
        // 注意：只要后续不删除这个id对应的元素，这个引用就始终有效
        children.get(&id).unwrap()
    }

    pub fn beep(&self) {}
}

fn main() {
    let parent = Parent::new();
    let child1 = parent.create_child(1);
    let child2 = parent.create_child(2);
    child1.borrow();
}

这种方式保留了返回&RefCell<Child>的形式，但需要注意：如果后续从HashMap中删除了对应的key，之前返回的引用会变成悬垂引用，这需要你在业务逻辑中保证不会发生这种情况。

3. 返回Rc<RefCell>（最灵活的通用方案） #

如果你的场景允许使用引用计数，推荐把Child包装在Rc<RefCell<Child>>中，这样create_child返回的是Rc实例而非直接引用，完全绕过了借用检查器的约束：

use std::{collections::HashMap, cell::RefCell, rc::Rc, error::Error};

struct Child(i32);

impl Child {
    pub fn new(id: i32) -> Child {
        Child(id)
    }
}

struct Parent {
    children: HashMap<i32, Rc<RefCell<Child>>>,
}

impl Parent {
    pub fn new() -> Parent {
        Parent {
            children: HashMap::new(),
        }
    }

    pub fn create_child(&mut self, id: i32) -> Rc<RefCell<Child>> {
        let child = Child::new(id);
        let cell = Rc::new(RefCell::new(child));
        // 克隆一份Rc存入HashMap，原实例返回给调用者
        self.children.insert(id, Rc::clone(&cell));
        cell
    }

    pub fn beep(&mut self) {}
}

fn main() {
    let mut parent = Parent::new();
    let child1 = parent.create_child(1);
    let child2 = parent.create_child(2);
    child1.borrow();
}

Rc允许你拥有多个对同一个Child的所有权，RefCell提供内部可变性，这样你可以随意调用create_child并同时持有多个子对象的引用。如果需要支持多线程，只需要把Rc换成Arc，RefCell换成Mutex或RwLock即可。

总结 #

• 简单场景：调整操作顺序即可快速解决；
• 需保留引用返回：用RefCell包裹Parent的内部状态，使用不可变引用操作；
• 追求灵活性：使用Rc<RefCell<Child>>（或多线程版本Arc<Mutex<Child>>）是最通用的方案。

内容的提问来源于stack exchange，提问作者Rick de Water