Rust 智能指针 RefCell＜T＞与内部可变性模式

Rust 智能指针：`RefCell<T>` 与内部可变性模式

在 Rust 的世界里，"所有权"和"借用规则"是保证内存安全的核心。然而，有时业务逻辑需要在不可变引用的情况下修改数据 。为了在遵守 Rust 安全底线的前提下实现这一点，标准库提供了一个强有力的工具：RefCell<T> 及其背后的内部可变性（Interior Mutability）模式。

1. 核心概念：什么是内部可变性？

Rust 的借用规则非常严苛：

在任意给定时刻，只能拥有 一个可变引用（&mut T）或任意数量的不可变引用（&T）之一。
引用必须总是有效的。

通常情况下，这些规则在编译时 由编译器强制检查。这意味着，如果你有一个不可变变量 let x = 5;，你就绝对不能通过它去修改它的值（let y = &mut x; 会直接导致编译报错）。

但有时候，我们明明可以确保代码在逻辑上是安全的，编译器却因为过于"保守"而拒绝编译。内部可变性 就是一种设计模式：它允许你在数据结构内部使用 unsafe 代码来放宽限制，从而在持有不可变引用时也能修改数据。

对于外部使用者而言，这个对象依然是不可变的，但其内部状态却可以悄悄发生改变。

2. 编译时检查 vs 运行时检查

Box<T>、Rc<T> 和 RefCell<T> 的核心区别在于它们执行借用规则的时机不同：

智能指针类型	所有权特征	借用检查时机	违反规则的后果
`Box<T>`	唯一所有者	编译时	编译错误
`Rc<T>`	多个所有者（不可变）	编译时	编译错误
`RefCell<T>`	唯一所有者	运行时	程序 Panic（崩溃）

为什么选择编译时检查？ 能在开发早期发现错误，且对运行性能零开销，是绝大多数情况下的首选。
为什么需要运行时检查（RefCell<T>）？ 编译器的静态分析是保守的。当有些内存安全的场景无法被编译器静态识别时，RefCell<T> 允许程序员在运行时 自己向借用检查器证明安全性。如果运行时刻不小心违反了规则，程序会直接 panic 退出，而不是无法通过编译。

注意： RefCell<T> 和 Rc<T> 一样，只能用于单线程场景 。如果在多线程下使用，会导致编译错误（多线程并发修改需要配合后面章节介绍的 Arc 和 Mutex）。

3. 经典应用场景：编写 Mock 对象进行测试

在编写单元测试时，我们经常需要用到 Mock 对象（测试替身） 来记录某个被测对象是否按预期发出了通知或调用了方法。

为什么常规写法行不通？

假设我们要测试一个限流器 LimitTracker：

当用户超出 75% 配额时，它会调用 messenger.send(&str) 发送警告。
在编写测试时，我们需要一个 MockMessenger 来记录被发送了多少条消息。

如果你尝试像下面这样编写代码：

rust 复制代码

pub trait Messenger {
    fn send(&self, msg: &str); // 注意：这里方法签名使用的是不可变借用 &self
}

struct MockMessenger {
    sent_messages: Vec<String>, // 用来记录消息的 Vector
}

impl Messenger for MockMessenger {
    fn send(&self, message: &str) {
        // 编译错误：self 是 &self（不可变借用），无法向 sent_messages 中 push 数据！
        self.sent_messages.push(String::from(message));
    }
}

问题所在 ：

Messenger trait 的设计规范要求 send 方法只能接收 &self（不可变引用），因为调用者在发送消息时并不一定拥有该 messenger 的可变所有权。然而，MockMessenger 在执行 send 时，核心任务就是修改自身的 sent_messages 列表（添加新消息）。这直接冲突了。

使用 `RefCell<T>` 完美解决

为了在 &self 不可变引用的情况下修改内部数据，我们可以把 sent_messages 用 RefCell<T> 包裹起来：

rust 复制代码

use std::cell::RefCell;

pub trait Messenger {
    fn send(&self, msg: &str);
}

struct MockMessenger {
    // 用 RefCell 包装 Vec，实现内部可变性
    sent_messages: RefCell<Vec<String>>,
}

impl MockMessenger {
    fn new() -> MockMessenger {
        MockMessenger {
            sent_messages: RefCell::new(vec![]),
        }
    }
}

impl Messenger for MockMessenger {
    fn send(&self, message: &str) {
        // 1. 调用 borrow_mut() 获得内部数据的可变引用
        // 2. 然后就可以正常修改内容了
        self.sent_messages.borrow_mut().push(String::from(message));
    }
}

在测试用例中使用它：

rust 复制代码

#[test]
fn it_sends_an_over_75_percent_warning_message() {
    let mock_messenger = MockMessenger::new();
    let limit_tracker = LimitTracker::new(&mock_messenger, 100);

    limit_tracker.set_value(80);

    // 验证 sent_messages 确实记录了一条消息
    assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
}

4. `RefCell` 提供的核心方法

当你使用 RefCell<T> 时，可以通过以下方法来安全地获取内部值：

borrow()：

返回内部数据的智能指针 Ref<T>，类似于不可变借用（&T）。
可以同时多次调用 borrow() 获得多个不可变借用。

borrow_mut()：

返回内部数据的智能指针 RefMut<T>，类似于可变借用（&mut T）。
运行时限制 ：如果在同一作用域内已经存在活跃的借用（无论是不可变还是可变），再次调用 borrow_mut() 会导致程序直接 panic! 崩溃。

5. 黄金组合：`Rc<T>` + `RefCell<T>`

Rc<T> 允许你拥有多个所有者 （共享数据），但它只提供只读访问。

RefCell<T> 允许你修改数据 ，但它只支持单一所有者。

当这两个智能指针结合在一起（即 Rc<RefCell<T>>）时，你便拥有了强大的威力：可以创建出"拥有多个所有者，且这些所有者都能共同修改同一份数据"的数据结构（例如图或树结构中的多向节点引用）。

Rust 智能指针 RefCell＜T＞ 与内部可变性模式