文章

Rust内部可变性

Rust内部可变性

问题:Rust 既然花了大量力气在编译期检查借用,为什么又允许RefCell绕过编译期检查?这不是把 Rust 的安全保证破坏了吗?

从一个最普通的例子开始。

Rust 到底在防止什么

假设有个变量:

1
2
3
4
5
6
7
let mut x = 5;

let a = &mut x;
let b = &mut x;

*a += 1;
*b += 1;

这段代码不能编译。因为 a 和 b 是两个同时有效、指向同一份数据的可变引用。

Rust 的核心借用规则是:

  • &T:大家可以同时读。
  • &mut T:一个人独占访问,可以读写,其他人暂时不能碰。

这不仅是为了避免多线程数据竞争。在单线程里,引用别名、迭代器失效和不受控的修改也会让程序难以推理。

RefCell 改变了什么?

先比较两个程序。

编译器直接拒绝

1
2
3
4
5
6
7
let mut x = 5;

let a = &mut x;
let b = &mut x; // 编译错误

*a += 1;
*b += 1;

编译器能够直接看到有两个冲突的可变借用,因此程序无法通过编译。

RefCell:编译成功,运行时检查

1
2
3
4
5
6
7
8
use std::cell::RefCell;

let x = RefCell::new(5); // 创建 RefCell 数据:5 尚未借用 内部状态:空闲 可以读或写

let a = x.borrow_mut(); // 数据:5 被 a 独占借用
let b = x.borrow_mut(); // 第二个独占借用被拒绝 运行到这里 panic

println!("{}", *a);

这里 borrow_mut() 接收的是 &self,所以编译器允许连续调用。但 RefCell 内部会记录当前有没有活跃的借用。

编译器没有证明操作一定合法,但RefCell有责任通过运行时状态保证非法操作不会成功。发生冲突时,RefCell 会 panic。

RefCell 必须知道借用什么时候结束

提问:borrow_mut() 执行完了,不就意味着可以再次调用了吗?

不是。

因为借用的生命周期,和函数调用的执行时间不是一回事。例如:

1
2
3
4
5
6
let x = RefCell::new(5);

let mut a = x.borrow_mut();

*a += 1;
*a += 1;

这里 a 一直持有对内部数据的独占访问权。

RefCell 必须保证,在 a 存活的这段时间里,别人不能再借用相同的数据。

Rust 为此设计了一个叫 RefMut<T> 的类型。

1
let a: RefMut<i32> = x.borrow_mut();

它不是普通的 &mut i32,而是一个借用守卫(borrow guard)。承担两个职责:

  1. 让你通过它访问数据,行为类似 &mut T。
  2. 当它被销毁(Drop)时,通知 RefCell:独占借用结束了。

例如:

1
2
3
4
5
6
7
8
9
let x = RefCell::new(5);

{
    let mut a = x.borrow_mut();
    *a += 1;
} // a 在这里 Drop,独占借用结束

let mut b = x.borrow_mut(); // 合法
*b += 1; // 最终得到 7。

也可以主动drop:

1
2
3
4
5
let a = x.borrow_mut();

drop(a); // 主动释放借用

let b = x.borrow_mut(); // 合法

这就是 RefCell 的重要设计技巧:使用 RAII,将运行时的借用状态绑定到一个有生命周期的守卫对象上。

需要注意,编译器也会检查守卫对象本身的借用生命周期,但是否允许创建新的 Ref / RefMut,仍由 RefCell 的运行时状态决定。

编译时与运行时检查的权衡

维度普通 &mut TRefCell<T>
冲突检查编译期运行时
运行时检查开销无借用计数开销需要维护借用状态
借用冲突编译失败panic 或 try_borrow 返回错误
可维护性较容易静态推理依赖实际执行路径
使用范围常规默认选择特定内部可变性场景

真正的风险通常不是内存不安全,而是某条不常执行的路径可能在生产环境中触发 panic。例如:

1
2
3
4
5
6
7
8
9
10
fn update(x: &RefCell<i32>) {
    let mut a = x.borrow_mut();
    *a += 1;

    notify(x);
}

fn notify(x: &RefCell<i32>) {
    *x.borrow_mut() += 10;
}

假设 update() 正在修改数据,过程中调用了 notify()。而 notify() 也要修改同一份数据。编译器允许这样写,但运行时 notify() 内部的第二次 borrow_mut() 会 panic。

这种情况叫做重入(reentrancy)引发的借用冲突,在回调、事件监听器、观察者模式中尤其容易遇到。

RefCell 给予的是更大的表达能力和灵活性,同时把一部分正确性责任从编译器转移到程序设计和测试上。

为什么 Rust 还要这样设计?

因为编译器检查不是万能的。

考虑一个常见的数据结构:多个节点共享一个对象。

1
2
3
4
5
6
7
8
9
10
use std::rc::Rc;

struct Node {
    value: i32,
}

let node = Rc::new(Node { value: 5 });

let a = Rc::clone(&node);
let b = Rc::clone(&node);

现在 a 和 b 都拥有这个节点的共享所有权。

你希望通过 a 修改节点,也希望 b 随后看到更新。但是 Rc<T> 提供共享所有权,并不默认允许通过共享引用修改 T。

一种解决方式是:

1
2
3
4
5
6
7
8
9
10
11
use std::cell::RefCell;
use std::rc::Rc;

let node = Rc::new(RefCell::new(5));

let a = Rc::clone(&node);
let b = Rc::clone(&node);

*a.borrow_mut() += 10;

println!("{}", b.borrow()); // 15

这里两层类型各有职责:

1
2
3
4
5
6
7
Rc<RefCell<i32>> 共享所有权 + 内部可变性

Rc 引用计数,允许多个所有者

RefCell 动态检查借用是否合法

5 真正的数据

这类结构在图、带父指针的树、GUI 组件、单线程事件系统中可能有用。

如果 Rust 只允许编译期可证明的借用,就会有一些运行时其实完全安全,但编译器无法通过静态分析证明安全的数据结构很难实现。

因此 Rust 提供 RefCell,让程序员选择动态检查。

但要注意,Rc<RefCell<T>> 不是万能的数据结构:它可能引入引用循环,借用范围也需要谨慎控制。

Rust 如何确保 RefCell 自身是安全的?

这里进入 Rust 最重要的一层设计:安全抽象(safe abstraction)。

RefCell 底层使用 UnsafeCell<T>,因为普通共享引用 &T 默认不允许修改其指向的数据。

UnsafeCell<T> 提供一个受控的底层能力:允许通过共享引用实现内部可变性。但它本身不会自动执行借用检查,也不会允许数据竞争。

RefCell 在此基础上维护借用状态、控制引用的创建,并通过守卫对象管理借用释放。

安全保证来自一个很重要的契约:

  • unsafe 实现者负责证明内部实现满足内存安全条件。
  • 安全 API 的使用者即使触发借用冲突,也不能仅靠安全代码造成 UB。
  • RefCell 的动态检查发现违反借用规则时,会阻止操作继续;默认 borrow_mut() 选择 panic,try_borrow_mut() 则返回 Result。

这也是为什么 Rust 允许标准库使用 unsafe:它不是简单禁止底层危险操作,而是允许经过审查的底层代码封装为有明确不变量的安全接口。

其他类型

类型管理方式为什么安全
Cell<T>值的整体替换、复制等不向外暴露可导致冲突的内部借用
RefCell<T>动态借用检查同一时刻遵守共享读或独占写
Mutex<T>互斥锁通过同步机制实现独占访问
RwLock<T>读写锁允许多个读者或一个写者
UnsafeCell<T>不提供上述保护由实现者维护安全不变量

例如 Mutex:它主要解决线程之间的同步问题,而不是照搬 RefCell 的借用计数机制。锁同样会通过守卫及其生命周期来管理访问。

安全的层次性

第一层:编译期保证

优先使用所有权和借用系统。无需动态借用检查,冲突在编译阶段被拒绝。

第二层:运行时保证

使用 RefCell、锁等安全抽象,在执行时维护必要的不变量。

第三层:unsafe 实现

对于无法由语言自动保证的底层操作,由实现者承担额外证明责任。

warning

本文由作者按照 CC BY 4.0 进行授权