RefCell<T> 运行时借用检查
什么是 RefCell<T>
Rust 的借用规则通常在编译期就进行检查:要么有多个不可变引用,要么只有一个可变引用。这套规则很严格,能在编译期就阻止大部分内存安全问题。但有时候,编译器无法证明你的代码是安全的,即使你自己知道它是安全的。
RefCell<T> 就是把借用检查从编译期推迟到运行时的工具。它在内部维护一个借用计数器,每次你调用 borrow() 或 borrow_mut() 时,它会在运行时检查是否违反了借用规则。如果违反了(比如已经有可变借用的情况下再借用),程序会 panic,而不是编译失败。
RefCell<T> 和 Cell<T> 一样,只能用在单线程环境。多线程下需要用 Mutex 或 RwLock。
RefCell 的借用规则
RefCell 在运行时执行的规则和编译期的借用规则完全一致:
- 同一时刻可以有多个不可变借用(
borrow()) - 同一时刻只能有一个可变借用(
borrow_mut()) - 不可变借用和可变借用不能同时存在
use std::cell::RefCell;
fn main() {
let data = RefCell::new(vec![1, 2, 3]);
// 多个不可变借用可以同时存在
{
let borrow1 = data.borrow();
let borrow2 = data.borrow();
println!("borrow1: {:?}", *borrow1);
println!("borrow2: {:?}", *borrow2);
// borrow1 和 borrow2 在这里离开作用域,不可变借用结束
}
// 可变借用必须独占
{
let mut borrow_mut = data.borrow_mut();
borrow_mut.push(4);
println!("修改后: {:?}", *borrow_mut);
// borrow_mut 在这里离开作用域,可变借用结束
}
// 违反规则会 panic
// {
// let borrow1 = data.borrow(); // 不可变借用
// let borrow_mut = data.borrow_mut(); // panic! 已经有不可变借用了
// }
}Ref<T> 和 RefMut<T>
borrow() 返回的不是普通的 &T,而是一个 Ref<T> 智能指针;borrow_mut() 返回 RefMut<T>。这两个类型实现了 Deref(和 DerefMut),所以用起来和普通引用几乎一样。它们的特殊之处在于:当 Ref 或 RefMut 被 drop 时,RefCell 内部的借用计数会自动更新。
use std::cell::{RefCell, Ref, RefMut};
fn main() {
let cell = RefCell::new(String::from("hello"));
// borrow() 返回 Ref<String>
let borrowed: Ref<String> = cell.borrow();
// Ref 实现了 Deref,可以直接调用 String 的方法
println!("长度: {}", borrowed.len());
println!("大写: {}", borrowed.to_uppercase());
// 手动 drop,释放不可变借用
drop(borrowed);
// borrow_mut() 返回 RefMut<String>
let mut borrowed_mut: RefMut<String> = cell.borrow_mut();
// RefMut 实现了 DerefMut,可以修改内部数据
borrowed_mut.push_str(", world");
println!("修改后: {}", *borrowed_mut);
// borrowed_mut 离开作用域时自动释放可变借用
}try_borrow 和 try_borrow_mut
borrow() 和 borrow_mut() 在违反借用规则时会直接 panic。如果你不想让程序崩溃,可以用 try_borrow() 和 try_borrow_mut(),它们返回 Result,让你有机会处理错误。
use std::cell::RefCell;
fn main() {
let data = RefCell::new(42);
// 先获取一个可变借用
let mut_borrow = data.borrow_mut();
// 用 try_borrow 尝试获取不可变借用
match data.try_borrow() {
Ok(val) => println!("值: {}", *val),
Err(e) => println!("借用失败: {}", e), // 会走到这里
}
// 用 try_borrow_mut 尝试获取另一个可变借用
match data.try_borrow_mut() {
Ok(mut val) => *val += 1,
Err(e) => println!("可变借用失败: {}", e), // 会走到这里
}
drop(mut_borrow);
// 释放之前的可变借用后,就能正常借用了
match data.try_borrow() {
Ok(val) => println!("现在可以借用了: {}", *val), // 42
Err(e) => println!("借用失败: {}", e),
}
}Rc<RefCell<T>>:共享可变数据
Rc<RefCell<T>> 是 Rust 单线程环境下"多个所有者共享可变数据"的标准模式。Rc 提供共享所有权,RefCell 提供内部可变性。
use std::cell::RefCell;
use std::rc::Rc;
// 一个简单的共享购物车
#[derive(Debug)]
struct ShoppingCart {
items: Vec<String>,
total: f64,
}
impl ShoppingCart {
fn new() -> Self {
ShoppingCart {
items: Vec::new(),
total: 0.0,
}
}
fn add_item(&mut self, name: &str, price: f64) {
self.items.push(String::from(name));
self.total += price;
}
fn item_count(&self) -> usize {
self.items.len()
}
}
// 用户界面组件,持有购物车的共享引用
struct CartWidget {
cart: Rc<RefCell<ShoppingCart>>,
}
impl CartWidget {
fn display(&self) {
// 通过 borrow() 获取不可变引用来读取
let cart = self.cart.borrow();
println!("购物车: {} 件商品, 总价: {:.2}", cart.item_count(), cart.total);
}
}
// 添加按钮组件,也持有购物车的共享引用
struct AddButton {
cart: Rc<RefCell<ShoppingCart>>,
}
impl AddButton {
fn click(&self, name: &str, price: f64) {
// 通过 borrow_mut() 获取可变引用来修改
self.cart.borrow_mut().add_item(name, price);
}
}
fn main() {
// 创建共享的购物车
let cart = Rc::new(RefCell::new(ShoppingCart::new()));
// 两个组件共享同一个购物车
let widget = CartWidget { cart: Rc::clone(&cart) };
let button = AddButton { cart: Rc::clone(&cart) };
// 通过按钮添加商品
button.click("Rust 编程之道", 89.0);
button.click("深入理解计算机系统", 139.0);
// 通过界面组件显示
widget.display();
// 输出: 购物车: 2 件商品, 总价: 228.00
// 也可以直接通过原始引用访问
println!("商品列表: {:?}", cart.borrow().items);
}RefCell 在 Mock 测试中的应用
这是 Rust 官方文档中的经典用例。当 trait 方法签名是 &self(不可变引用),但 Mock 实现需要记录调用信息时,RefCell 就派上用场了。
use std::cell::RefCell;
// 消息发送 trait,send 方法只接受 &self
trait Messenger {
fn send(&self, msg: &str);
}
// Mock 实现:需要记录发送过的消息
struct MockMessenger {
// 因为 send 的签名是 &self,不能用 &mut self
// 所以用 RefCell 来实现内部可变性
sent_messages: RefCell<Vec<String>>,
}
impl MockMessenger {
fn new() -> Self {
MockMessenger {
sent_messages: RefCell::new(Vec::new()),
}
}
}
impl Messenger for MockMessenger {
fn send(&self, msg: &str) {
// 通过 RefCell 的 borrow_mut 修改内部数据
// 即使 self 是不可变引用也能修改
self.sent_messages.borrow_mut().push(String::from(msg));
}
}
// 额度追踪器
struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T: Messenger> LimitTracker<'a, T> {
fn new(messenger: &'a T, max: usize) -> Self {
LimitTracker {
messenger,
value: 0,
max,
}
}
fn set_value(&mut self, value: usize) {
self.value = value;
let percentage = self.value as f64 / self.max as f64;
if percentage >= 1.0 {
self.messenger.send("已超出额度!");
} else if percentage >= 0.9 {
self.messenger.send("已使用 90% 的额度");
} else if percentage >= 0.75 {
self.messenger.send("已使用 75% 的额度");
}
}
}
fn main() {
let mock = MockMessenger::new();
let mut tracker = LimitTracker::new(&mock, 100);
tracker.set_value(80);
// 检查 mock 记录的消息
let messages = mock.sent_messages.borrow();
println!("发送了 {} 条消息", messages.len());
println!("消息内容: {:?}", *messages);
// 输出:
// 发送了 1 条消息
// 消息内容: ["已使用 75% 的额度"]
}RefCell 的常用方法
use std::cell::RefCell;
fn main() {
// new: 创建 RefCell
let cell = RefCell::new(vec![1, 2, 3]);
// borrow: 获取不可变借用,返回 Ref<T>
{
let r = cell.borrow();
println!("borrow: {:?}", *r);
}
// borrow_mut: 获取可变借用,返回 RefMut<T>
{
let mut r = cell.borrow_mut();
r.push(4);
println!("borrow_mut 后: {:?}", *r);
}
// try_borrow / try_borrow_mut: 非 panic 版本
{
let r = cell.try_borrow();
println!("try_borrow: {:?}", r.is_ok()); // true
}
// replace: 替换内部值,返回旧值
let old = cell.replace(vec![10, 20]);
println!("replace 旧值: {:?}", old);
println!("replace 新值: {:?}", cell.borrow());
// take: 取出值,留下默认值
let taken = cell.take();
println!("take 拿到: {:?}", taken); // [10, 20]
println!("take 后: {:?}", cell.borrow()); // []
// into_inner: 消费 RefCell,取出内部值
let cell2 = RefCell::new(String::from("hello"));
let inner = cell2.into_inner();
println!("into_inner: {}", inner);
// swap: 交换两个 RefCell 的值
let a = RefCell::new(1);
let b = RefCell::new(2);
a.swap(&b);
println!("swap: a={}, b={}", a.borrow(), b.borrow()); // 2, 1
}借用作用域的陷阱
使用 RefCell 时最常见的错误就是借用的作用域管理不当,导致运行时 panic。
use std::cell::RefCell;
fn main() {
let data = RefCell::new(vec![1, 2, 3]);
// 错误示范:不可变借用和可变借用的作用域重叠
// let borrowed = data.borrow();
// let mut borrowed_mut = data.borrow_mut(); // panic!
// println!("{:?}", borrowed);
// 正确做法一:用花括号限制作用域
{
let borrowed = data.borrow();
println!("读取: {:?}", *borrowed);
} // borrowed 在这里被 drop,不可变借用结束
{
let mut borrowed_mut = data.borrow_mut();
borrowed_mut.push(4);
} // borrowed_mut 在这里被 drop,可变借用结束
// 正确做法二:手动 drop
let borrowed = data.borrow();
println!("读取: {:?}", *borrowed);
drop(borrowed); // 手动释放借用
let mut borrowed_mut = data.borrow_mut();
borrowed_mut.push(5);
drop(borrowed_mut);
println!("最终: {:?}", data.borrow());
}while let 中的临时变量陷阱(Rust 2021 Edition)
use std::cell::RefCell;
struct Counter {
val: i32,
}
impl Counter {
fn increment(&mut self) -> Option<i32> {
if self.val >= 3 {
return None;
}
self.val += 1;
Some(self.val)
}
}
fn main() {
let r = RefCell::new(Counter { val: 0 });
// 在 Rust 2021 edition 中,下面的代码会 panic
// 因为 borrow_mut() 返回的 RefMut 临时变量
// 在 while let 中的生命周期会延伸到整个循环体
// while let Some(v) = r.borrow_mut().increment() {
// println!("值: {}", v);
// println!("当前: {}", r.borrow().val); // panic! RefMut 还没释放
// }
// 正确做法:用大括号创建独立的表达式作用域
while let Some(v) = { r.borrow_mut().increment() } {
println!("值: {}", v);
println!("当前: {}", r.borrow().val); // 在 2024 edition 中正常工作
}
}基本示例
一个综合示例:用 Rc<RefCell<T>> 实现观察者模式。
use std::cell::RefCell;
use std::rc::Rc;
// 事件类型
#[derive(Debug, Clone)]
enum Event {
DataChanged(String),
UserAction(String),
}
// 观察者 trait
trait Observer {
fn on_event(&self, event: &Event);
fn name(&self) -> &str;
}
// 事件总线:管理观察者并分发事件
struct EventBus {
// 观察者列表,需要共享所有权(Rc)和运行时修改(RefCell)
observers: RefCell<Vec<Rc<dyn Observer>>>,
// 事件历史记录
history: RefCell<Vec<Event>>,
}
impl EventBus {
fn new() -> Self {
EventBus {
observers: RefCell::new(Vec::new()),
history: RefCell::new(Vec::new()),
}
}
// 注册观察者(&self,不需要 &mut self)
fn subscribe(&self, observer: Rc<dyn Observer>) {
println!("注册观察者: {}", observer.name());
self.observers.borrow_mut().push(observer);
}
// 发布事件(&self,不需要 &mut self)
fn publish(&self, event: Event) {
// 记录事件
self.history.borrow_mut().push(event.clone());
// 通知所有观察者
let observers = self.observers.borrow();
for observer in observers.iter() {
observer.on_event(&event);
}
}
// 获取事件数量
fn event_count(&self) -> usize {
self.history.borrow().len()
}
}
// 日志观察者
struct LogObserver {
// 用 RefCell 记录日志(因为 on_event 是 &self)
logs: RefCell<Vec<String>>,
}
impl LogObserver {
fn new() -> Self {
LogObserver {
logs: RefCell::new(Vec::new()),
}
}
fn print_logs(&self) {
let logs = self.logs.borrow();
println!("=== 日志 ({} 条) ===", logs.len());
for log in logs.iter() {
println!(" {}", log);
}
}
}
impl Observer for LogObserver {
fn on_event(&self, event: &Event) {
let log_entry = format!("[LOG] {:?}", event);
self.logs.borrow_mut().push(log_entry);
}
fn name(&self) -> &str {
"日志观察者"
}
}
// 计数观察者
struct CountObserver {
count: RefCell<u32>,
}
impl CountObserver {
fn new() -> Self {
CountObserver {
count: RefCell::new(0),
}
}
fn get_count(&self) -> u32 {
self.count.borrow().clone()
}
}
impl Observer for CountObserver {
fn on_event(&self, _event: &Event) {
// 每收到一个事件,计数加一
let mut count = self.count.borrow_mut();
*count += 1;
}
fn name(&self) -> &str {
"计数观察者"
}
}
fn main() {
let bus = EventBus::new();
// 创建观察者
let logger = Rc::new(LogObserver::new());
let counter = Rc::new(CountObserver::new());
// 注册观察者
bus.subscribe(Rc::clone(&logger) as Rc<dyn Observer>);
bus.subscribe(Rc::clone(&counter) as Rc<dyn Observer>);
// 发布事件
bus.publish(Event::UserAction(String::from("登录")));
bus.publish(Event::DataChanged(String::from("更新配置")));
bus.publish(Event::UserAction(String::from("提交订单")));
// 查看结果
logger.print_logs();
println!("计数观察者收到 {} 个事件", counter.get_count());
println!("事件总线共处理 {} 个事件", bus.event_count());
}常见问题
问题一:RefCell 什么时候会 panic?
当你违反借用规则时会 panic,具体有两种情况:(1)已经有可变借用时,再调用 borrow() 或 borrow_mut();(2)已经有不可变借用时,调用 borrow_mut()。用 try_borrow / try_borrow_mut 可以避免 panic,它们返回 Result 让你处理错误。
问题二:RefCell 和编译期借用检查有什么区别?
| 对比项 | 编译期检查(&T / &mut T) | 运行时检查(RefCell) |
|---|---|---|
| 检查时机 | 编译期 | 运行时 |
| 违反规则的后果 | 编译失败 | 程序 panic |
| 性能开销 | 零开销 | 有借用计数开销 |
| 灵活性 | 受编译器限制 | 更灵活 |
| 安全性 | 保证不会出问题 | 可能在运行时崩溃 |
问题三:RefCell 和 Mutex 有什么关系?
两者都提供内部可变性,但应用场景不同。RefCell 只用于单线程,通过借用计数检查安全性;Mutex 用于多线程,通过操作系统的互斥锁实现同步。Mutex 的开销比 RefCell 大得多。在单线程中,RefCell 是更轻量的选择。
问题四:Ref 和 RefMut 的生命周期应该如何管理?
尽量让 Ref 和 RefMut 的生命周期越短越好。用花括号限制作用域是最清晰的做法。如果需要在一个作用域内先读后写,先 drop 掉 Ref,再获取 RefMut。不要把 Ref 或 RefMut 存到结构体字段中,这样很容易导致借用冲突。
适用场景
- Rc<RefCell<T>> 模式:单线程环境下多个所有者共享可变数据的标准方案
- Mock 和测试:trait 方法签名是
&self但实现中需要修改状态 - 观察者/回调模式:事件处理器需要在不可变上下文中修改内部状态
- 图和树数据结构:节点之间有复杂的引用关系,编译器难以验证借用安全性
- 惰性初始化:在首次访问时才计算并缓存结果(也可考虑
OnceCell) - 不可变接口下的可变实现:对外暴露不可变 API,内部需要修改状态
注意事项
RefCell不是线程安全的,不能跨线程使用。多线程环境用Mutex或RwLock- 运行时违反借用规则会 panic,而不是编译错误。在可能出问题的地方用
try_borrow/try_borrow_mut Ref和RefMut的作用域决定了借用的持续时间,要注意及时释放- 在
while let和if let表达式中,临时变量的生命周期可能比你想象的长,注意 Rust edition 的差异 RefCell有运行时开销:每次borrow和borrow_mut都需要检查和更新借用计数器- 避免在持有
RefMut的时候调用可能再次借用同一个 RefCell 的函数,这是导致 panic 的常见原因 RefCell的借用计数不是原子操作,这也是它不能跨线程的原因之一
总结
RefCell<T> 把 Rust 的借用检查从编译期推迟到了运行时。它在运行时维护一个借用计数器,确保同一时刻只有多个不可变借用或一个可变借用,违反规则时 panic 而不是编译失败。RefCell 最重要的使用模式是 Rc<RefCell<T>>,它解决了单线程环境下"多个所有者需要修改同一份数据"的问题。和 Cell<T> 相比,RefCell 可以处理任何类型(不限于 Copy 类型),并且可以获取内部数据的引用(Ref<T> 和 RefMut<T>),代价是运行时的借用检查开销和潜在的 panic 风险。使用 RefCell 时,关键是管理好 Ref 和 RefMut 的生命周期,让借用尽早释放,避免作用域重叠导致 panic。