如何修改Rust代码解决Cannot borrow as mutable多次借用编译错误？

问题描述 #

需求是实现一个生产者消费者结构，能够获取集合中元素的可变引用（acquire），对其进行写入操作，不再需要时释放（release）该引用。原代码编译失败，错误在于可变借用冲突。

原代码 #

use std::{collections::VecDeque, str::FromStr};

struct Elem {
    value: String,
    flag: bool,
}

impl Default for Elem {
    fn default() -> Self {
        Self { value: Default::default(), flag: false }
    }
}

struct ProdCons {
    buffer: VecDeque<Elem>,
    foo: bool
}

impl ProdCons {
    fn acquire(&mut self) -> &mut Elem {
        self.foo = true;

        self.buffer.push_back(Default::default());

        let elem = self.buffer.back_mut().unwrap();
        elem.flag = true;

        self.foo = false;

        return elem
    }

    fn release(&mut self, elem: &mut Elem) {
        self.foo = true;

        elem.flag = false;

        self.foo = false;
    }
}

fn main() {
    let mut pc = ProdCons{ buffer: VecDeque::new(), foo: false };

    let elem = pc.acquire();
    elem.value = String::from_str("test").unwrap();

    pc.release(elem);
}

编译错误信息 #

error[E0499]: cannot borrow `pc` as mutable more than once at a time
  --> src\main.rs:50:5
   |
47 |     let elem = pc.acquire();
   |                ------------ first mutable borrow occurs here
...
50 |     pc.release(elem);
   |     ^^^^^^^^^^^----^
   |     |          |
   |     |          first borrow later used here
   |     second mutable borrow occurs here

问题根源 #

acquire方法返回的&mut Elem持有对ProdCons的可变借用，当调用release时需要再次可变借用ProdCons，这违反了Rust的核心借用规则：同一时间只能存在一个可变借用。即使你明确release是引用的结束点，Rust的借用检查器无法通过原代码的结构识别这一点。

解决方案 #

方案1：RAII守卫模式（推荐，符合Rust惯用法） #

通过创建一个RAII守卫结构体，将ProdCons的可变借用与元素引用绑定，当守卫被销毁时自动执行释放逻辑。这样借用检查器能准确跟踪借用生命周期，避免冲突。

修改后的代码：

use std::{collections::VecDeque, str::FromStr};

struct Elem {
    value: String,
    flag: bool,
}

impl Default for Elem {
    fn default() -> Self {
        Self { value: Default::default(), flag: false }
    }
}

struct ProdCons {
    buffer: VecDeque<Elem>,
    foo: bool
}

impl ProdCons {
    fn acquire(&mut self) -> ElemGuard<'_> {
        self.foo = true;

        self.buffer.push_back(Default::default());
        let elem = self.buffer.back_mut().unwrap();
        elem.flag = true;

        self.foo = false;

        ElemGuard { pc: self, elem }
    }

    fn release(&mut self, elem: &mut Elem) {
        self.foo = true;
        elem.flag = false;
        self.foo = false;
    }
}

// RAII守卫结构体，自动管理元素的释放
struct ElemGuard<'a> {
    pc: &'a mut ProdCons,
    elem: &'a mut Elem,
}

impl<'a> ElemGuard<'a> {
    // 获取元素的可变引用
    fn elem(&mut self) -> &mut Elem {
        self.elem
    }
}

// 实现Drop trait，自动触发释放逻辑
impl<'a> Drop for ElemGuard<'a> {
    fn drop(&mut self) {
        self.pc.release(self.elem);
    }
}

fn main() {
    let mut pc = ProdCons{ buffer: VecDeque::new(), foo: false };

    {
        let mut elem_guard = pc.acquire();
        let elem = elem_guard.elem();
        elem.value = String::from_str("test").unwrap();
        // 离开当前作用域时，ElemGuard被销毁，自动调用release
    }

    // 此时pc可正常被再次借用
}

方案2：使用索引替代引用 #

通过返回元素的索引而非直接返回可变引用，避免持有长期的可变借用。这种方式需要保证索引在acquire到release期间始终有效（比如不删除对应元素）。

修改后的代码：

use std::{collections::VecDeque, str::FromStr};

struct Elem {
    value: String,
    flag: bool,
}

impl Default for Elem {
    fn default() -> Self {
        Self { value: Default::default(), flag: false }
    }
}

struct ProdCons {
    buffer: VecDeque<Elem>,
    foo: bool
}

impl ProdCons {
    fn acquire(&mut self) -> usize {
        self.foo = true;

        self.buffer.push_back(Default::default());
        let idx = self.buffer.len() - 1;
        if let Some(elem) = self.buffer.get_mut(idx) {
            elem.flag = true;
        }

        self.foo = false;

        idx
    }

    fn release(&mut self, idx: usize) {
        self.foo = true;
        if let Some(elem) = self.buffer.get_mut(idx) {
            elem.flag = false;
        }
        self.foo = false;
    }

    // 通过索引获取元素的可变引用
    fn get_elem_mut(&mut self, idx: usize) -> Option<&mut Elem> {
        self.buffer.get_mut(idx)
    }
}

fn main() {
    let mut pc = ProdCons{ buffer: VecDeque::new(), foo: false };

    let elem_idx = pc.acquire();
    if let Some(elem) = pc.get_elem_mut(elem_idx) {
        elem.value = String::from_str("test").unwrap();
    }

    pc.release(elem_idx);
}

方案说明 #

• RAII模式：将ProdCons的可变借用封装在守卫中，确保在守卫存活期间pc无法被再次借用，守卫销毁时自动释放元素，完全符合Rust的安全规则，是最推荐的实现方式。
• 索引模式：通过索引间接操作元素，避免了长期可变引用，借用检查器会认为每次调用方法都是独立的可变借用，只要保证索引有效性就能正常工作。

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