Rust结构体函数调用时借用检查器报错的解决方法

在Rust开发中，常会遇到这种场景：结构体包含多个互相独立的组件，开发者明确当前操作不存在引用生命周期或所有权冲突，但借用检查器无法识别这种细粒度的安全操作，导致编译失败。典型例子就是结构体包含多个容器类型时，操作其中一个容器的同时，想要调用另一个仅操作其他容器的方法。

示例代码 #

use std::collections::VecDeque;
use std::collections::BTreeMap;

struct MyData {
    data: i32,
    another_data: i32,
}

struct ContainsTwoThings {
    thing1: BTreeMap<i32, VecDeque<MyData>>,
    thing2: VecDeque<MyData>,
}

impl ContainsTwoThings {
    fn process_event_queue(&mut self, index: &i32) {
        // 仅当index存在且对应数据满足条件时处理
        match self.thing1.get_mut(index) {
            Some(queue) => {
                while let Some(element) = queue.front() {
                    if element.data >= 4 {
                        let element = queue.pop_front().unwrap();
                        self.process_it(element, index); // 此处触发编译错误
                    } else {
                        break;
                    }
                }
            }
            None => {}
        }
    }
    
    fn process_it(&mut self, element: MyData, index: &i32) {
        println!("index: {}, element.data = {}", index, element.data);
        self.thing2.push_back(element); // 实际仅操作thing2
    }
}

fn main() {
    let mut my_struct = ContainsTwoThings {
        thing1: BTreeMap::new(),
        thing2: VecDeque::new(),
    };
}

编译错误 #

Compiling playground v0.0.1 (/playground)
error[E0499]: cannot borrow `*self` as mutable more than once at a time
  --> src/main.rs:34:25
   |
26 |         match self.thing1.get_mut(index) {
   |               -------------------------- first mutable borrow occurs here
...
30 |                 while let Some(element) = queue.front() {
   |                                           ------------- first borrow later used here
...
34 |                         self.process_it(element, index);
   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ second mutable borrow occurs here

问题原因 #

Rust的借用检查器是基于结构体整体进行借用跟踪的，而非单个成员。当调用self.thing1.get_mut(index)获取到thing1的可变引用后，整个self被标记为已可变借用。此时再调用需要&mut self的process_it，哪怕process_it仅操作thing2，编译器也无法识别这种局部操作的安全性，因此判定为重复可变借用。

解决方案 #

方案1：临时收集元素，延后处理

最直接的修改方式是先将需要处理的元素从thing1中取出并收集到临时容器中，待释放thing1的可变引用后，再统一调用process_it。这样就不会同时持有self的多个可变引用：

fn process_event_queue(&mut self, index: &i32) {
    let mut to_process = Vec::new();
    match self.thing1.get_mut(index) {
        Some(queue) => {
            while let Some(element) = queue.front() {
                if element.data >= 4 {
                    let element = queue.pop_front().unwrap();
                    to_process.push(element);
                } else {
                    break;
                }
            }
        }
        None => {}
    }
    // 此时thing1的可变引用已释放，可安全调用&mut self方法
    for element in to_process {
        self.process_it(element, index);
    }
}

方案2：拆分结构体，分离独立组件

将结构体中互相独立的组件拆分为子结构体，让借用检查器能够识别不同组件的独立性。这种方式最符合Rust的所有权设计理念：

struct Thing1 {
    inner: BTreeMap<i32, VecDeque<MyData>>,
}

struct Thing2 {
    inner: VecDeque<MyData>,
}

struct ContainsTwoThings {
    thing1: Thing1,
    thing2: Thing2,
}

impl ContainsTwoThings {
    fn process_event_queue(&mut self, index: &i32) {
        match self.thing1.inner.get_mut(index) {
            Some(queue) => {
                while let Some(element) = queue.front() {
                    if element.data >= 4 {
                        let element = queue.pop_front().unwrap();
                        // 直接借用thing2的可变引用，而非整个self
                        self.thing2.process_it(element, index);
                    } else {
                        break;
                    }
                }
            }
            None => {}
        }
    }
}

impl Thing2 {
    fn process_it(&mut self, element: MyData, index: &i32) {
        println!("index: {}, element.data = {}", index, element.data);
        self.inner.push_back(element);
    }
}

方案3：使用std::mem::take转移所有权

通过std::mem::take将thing1的所有权临时转移到局部变量，操作完成后再放回结构体。这种方式会让结构体的thing1临时变为默认值（空的BTreeMap），从而避免借用冲突：

fn process_event_queue(&mut self, index: &i32) {
    // 临时取出thing1的所有权
    let mut thing1 = std::mem::take(&mut self.thing1);
    if let Some(queue) = thing1.get_mut(index) {
        while let Some(element) = queue.front() {
            if element.data >= 4 {
                let element = queue.pop_front().unwrap();
                // 此时self的thing1是空的，可安全调用&mut self方法
                self.process_it(element, index);
            } else {
                break;
            }
        }
    }
    // 将thing1放回结构体
    self.thing1 = thing1;
}

方案4：内部可变性（RefCell）

如果无法拆分结构体且不想调整逻辑，可以使用RefCell为thing2提供内部可变性。这种方式会将可变检查从编译期移到运行期，需要确保操作确实安全（避免运行时panic）：

use std::cell::RefCell;

struct ContainsTwoThings {
    thing1: BTreeMap<i32, VecDeque<MyData>>,
    thing2: RefCell<VecDeque<MyData>>,
}

impl ContainsTwoThings {
    // 此处不再需要&mut self
    fn process_event_queue(&self, index: &i32) {
        match self.thing1.get_mut(index) {
            Some(queue) => {
                while let Some(element) = queue.front() {
                    if element.data >= 4 {
                        let element = queue.pop_front().unwrap();
                        self.process_it(element, index);
                    } else {
                        break;
                    }
                }
            }
            None => {}
        }
    }
    
    fn process_it(&self, element: MyData, index: &i32) {
        println!("index: {}, element.data = {}", index, element.data);
        // 使用borrow_mut获取可变引用
        self.thing2.borrow_mut().push_back(element);
    }
}

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