Rust Mutability

可变性

核心问题

数据需要变化吗？谁来控制变化？

可变性是程序状态改变的方式，需要谨慎设计。

可变性类型

借用规则

任何时刻只能有：
├─ 多个 &T（不可变借用）
└─ 或者一个 &mut T（可变借用）

两者不能同时存在

错误码速查

何时用内部可变性

// 情况1：从 &self 获取 &mut T
struct Config {
    counters: RefCell<HashMap<String, u32>>,
}

impl Config {
    fn increment(&self, key: &str) {
        // 从不可变引用获取可变引用
        let mut counters = self.counters.borrow_mut();
        *counters.entry(key.to_string()).or_insert(0) += 1;
    }
}

// 情况2：Copy 类型
struct State {
    count: Cell<u32>,
}

impl State {
    fn increment(&self) {
        self.count.set(self.count.get() + 1);
    }
}

线程安全选择

// 简单计数器 → 原子类型
let counter = AtomicU64::new(0);

// 复杂数据 → Mutex 或 RwLock
let data = Mutex::new(HashMap::new());

// 读多写少 → RwLock
let data = RwLock::new(HashMap::new());

常见问题

借用冲突

// ❌ 借用冲突
let mut s = String::new();
let r1 = &s;
let r2 = &s;
let r3 = &mut s; // 冲突！

// ✅ 分开作用域
let mut s = String::new();
{
    let r1 = &s;
    // 使用 r1
}
let r3 = &mut s;
// 使用 r3

RefCell panic

// ❌ 双重可变借用
let cell = RefCell::new(vec![]);
let mut_borrow = cell.borrow_mut();
let another = cell.borrow(); // panic!

// ✅ 用 try_borrow 避免 panic
if let Ok(mut_borrow) = cell.try_borrow_mut() {
    // 安全使用
}

设计建议

1. 变异是必要的吗？

   • 也许可以返回新值
   • 也许可以 immutable 构造

2. 谁控制变异？

   • 外部调用者 → &mut T
   • 内部逻辑 → 内部可变性
   • 并发访问 → 同步原语

3. 线程上下文？

   • 单线程 → Cell/RefCell
   • 多线程 → Mutex/RwLock/Atomic

向上追踪

借用冲突持续时：

E0499/E0502 (借用冲突)
    ↑ 问：数据结构设计正确吗？
    ↑ 查 rust-type-driven：应该拆分数据吗？
    ↑ 查 rust-concurrency：涉及 async 吗？