Rust中Arc<Mutex>包裹结构体的多字段可变借用问题

代码示例背景 #

示例1：直接操作可变结构体字段可正常运行 #

#[derive(Debug)]
struct Test{
    str1 : Option<String>,
    str2 : Option<String>,
}
fn main() {
    let mut test = Test{
        str1 : Some(String::from("str1")),
        str2 : Some(String::from("str2"))
    };
    let str1 = test.str1.as_mut().unwrap();
    let str2 = test.str2.as_mut().unwrap();
    *str1 = String::from("nonono1");
    *str2 = String::from("nonono2");
    println!("{:?}", test);
}

示例2：先修改一个字段再借用另一个，可正常运行 #

use std::sync::{
    Arc, Mutex
};
#[derive(Debug)]
struct Test{
    str1 : Option<String>,
    str2 : Option<String>,
}
fn main() {
    let test = Test{
        str1 : Some(String::from("str1")),
        str2 : Some(String::from("str2"))
    };
    let test = Arc::new(Mutex::new(test));
    let mut test = test.lock().unwrap();
    let str1 = test.str1.as_mut().unwrap();
    *str1 = String::from("nonono1");
    let str2 = test.str2.as_mut().unwrap();
    *str2 = String::from("nonono2");
    println!("{:?}", test);
}

示例3：同时借用两个字段，无法运行 #

use std::sync::{
    Arc, Mutex
};
#[derive(Debug)]
struct Test{
    str1 : Option<String>,
    str2 : Option<String>,
}
fn main() {
    let test = Test{
        str1 : Some(String::from("str1")),
        str2 : Some(String::from("str2"))
    };
    let test = Arc::new(Mutex::new(test));
    let mut test = test.lock().unwrap();
    let str1 = test.str1.as_mut().unwrap();
    let str2 = test.str2.as_mut().unwrap();
    *str1 = String::from("nonono1");
    *str2 = String::from("nonono2");
    println!("{:?}", test);
}

原因分析 #

直接操作结构体时，Rust的借用检查器能明确识别两个字段属于独立内存区域，因此允许同时创建两个可变引用。但结构体被MutexGuard（lock()方法的返回值）包裹后，借用检查器无法穿透MutexGuard识别内部字段的独立性——它只会判定我们从同一个MutexGuard实例尝试创建两次可变借用，违反了"同一时间只能有一个可变借用"的核心规则。

解决方案 #

可以通过显式解构MutexGuard内部的结构体，让借用检查器看到两个字段的独立性，从而实现同时可变借用：

use std::sync::{Arc, Mutex};
#[derive(Debug)]
struct Test{
    str1 : Option<String>,
    str2 : Option<String>,
}
fn main() {
    let test = Test{
        str1 : Some(String::from("str1")),
        str2 : Some(String::from("str2"))
    };
    let test = Arc::new(Mutex::new(test));
    let mut test_guard = test.lock().unwrap();
    // 显式解构出两个字段的可变引用
    let Test { str1, str2 } = &mut *test_guard;
    let str1 = str1.as_mut().unwrap();
    let str2 = str2.as_mut().unwrap();
    *str1 = String::from("nonono1");
    *str2 = String::from("nonono2");
    println!("{:?}", test_guard);
}

这段代码中，我们先通过&mut *test_guard获取结构体的可变引用，再解构出两个字段的可变引用，此时借用检查器能确认两个引用指向不同字段，因此允许同时存在。

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