如何避免向函数同时传递结构体及其字段的可变引用？

你遇到的是Rust借用检查器的经典限制：同一作用域内不能同时存在多个可变引用。针对你的场景，这里有几种实用的解决思路：

1. 重构函数参数，仅传递需要的字段引用 #

既然foo函数实际只需要操作d和Shared里的部分字段（比如inv_data），没必要传递整个Shared的可变引用。直接把需要的字段作为参数传入，避免借用整个结构体：

修改后的代码：

use std::sync::Mutex;
use std::collections::HashMap;

#[derive(Default)]
struct Shared {
    data: HashMap<i32, i32>,
    inv_data: HashMap<i32, i32>,
    // 其他字段
}

// 只传入需要的字段引用，而非整个Shared
fn foo(d: &mut i32, inv_data: &mut HashMap<i32, i32>) {
    // 这里操作inv_data和d
    *d += 1;
    inv_data.insert(*d, 1);
}

fn main() {
    let mutex_data = Mutex::new(Shared::default());
    {
        let mut sh = mutex_data.lock().unwrap();
        sh.data.insert(1, 1);
        sh.data.insert(2, 2);
    }
    
    {
        let mut sh = mutex_data.lock().unwrap();
        let data = sh.data.get_mut(&1).unwrap();
        // 传入inv_data的可变引用，而非整个sh
        foo(data, &mut sh.inv_data);
    }
}

这种方法最直接，没有额外开销，符合Rust的借用规则，是优先推荐的方案。

2. 拆分结构体，按逻辑分组字段 #

如果Shared的字段可以按逻辑拆分成独立的子结构体，比如把关联度高的字段归为一组，这样就能分别借用不同子结构体的可变引用，不会冲突：

use std::sync::Mutex;
use std::collections::HashMap;

#[derive(Default)]
struct DataPair {
    data: HashMap<i32, i32>,
    inv_data: HashMap<i32, i32>,
}

#[derive(Default)]
struct Shared {
    pair: DataPair,
    // 其他独立字段
}

fn foo(d: &mut i32, pair: &mut DataPair) {
    *d += 1;
    pair.inv_data.insert(*d, 1);
}

fn main() {
    let mutex_data = Mutex::new(Shared::default());
    {
        let mut sh = mutex_data.lock().unwrap();
        sh.pair.data.insert(1, 1);
    }
    
    {
        let mut sh = mutex_data.lock().unwrap();
        let data = sh.pair.data.get_mut(&1).unwrap();
        // 借用子结构体pair，而非整个Shared
        foo(data, &mut sh.pair);
    }
}

这种方案适合结构体字段较多、逻辑上可以分组的场景，能让代码结构更清晰。

3. 重新组织代码逻辑，避免同时持有可变引用 #

如果业务逻辑允许，可以调整代码顺序，先完成对data字段的修改，再操作结构体的其他部分，或者反过来，这样就不会同时持有两个可变引用：

use std::sync::Mutex;
use std::collections::HashMap;

#[derive(Default)]
struct Shared {
    data: HashMap<i32, i32>,
    inv_data: HashMap<i32, i32>,
}

// 拆分逻辑：先处理d，再处理Shared
fn process_d(d: &mut i32) -> i32 {
    *d += 1;
    *d
}

fn process_shared(sh: &mut Shared, new_val: i32) {
    sh.inv_data.insert(new_val, 1);
}

fn main() {
    let mutex_data = Mutex::new(Shared::default());
    {
        let mut sh = mutex_data.lock().unwrap();
        sh.data.insert(1, 1);
    }
    
    {
        let mut sh = mutex_data.lock().unwrap();
        {
            // 先修改data字段，作用域结束后借用自动释放
            let data = sh.data.get_mut(&1).unwrap();
            let new_val = process_d(data);
        }
        // 此时可以安全借用整个sh的可变引用
        process_shared(&mut sh, 2);
    }
}

这种方案不需要修改函数签名，适合逻辑容易拆分的场景。

注意：避免使用RefCell（多线程场景） #

虽然RefCell可以在运行时检查借用规则，允许内部可变性，但它不是线程安全的，和你代码里的Mutex一起使用会导致编译错误，所以不适合当前的多线程场景。

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