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)。承担两个职责:
- 让你通过它访问数据,行为类似
&mut T。 - 当它被销毁(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 T | RefCell<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 实现
对于无法由语言自动保证的底层操作,由实现者承担额外证明责任。
