RefCell<T> 运行时借用检查 ​

什么是 RefCell<T> ​

Rust 的借用规则通常在编译期就进行检查:要么有多个不可变引用,要么只有一个可变引用。这套规则很严格,能在编译期就阻止大部分内存安全问题。但有时候,编译器无法证明你的代码是安全的,即使你自己知道它是安全的。

RefCell<T> 就是把借用检查从编译期推迟到运行时的工具。它在内部维护一个借用计数器,每次你调用 borrow() 或 borrow_mut() 时,它会在运行时检查是否违反了借用规则。如果违反了(比如已经有可变借用的情况下再借用),程序会 panic,而不是编译失败。

RefCell<T> 和 Cell<T> 一样,只能用在单线程环境。多线程下需要用 Mutex 或 RwLock。

RefCell 的借用规则 ​

RefCell 在运行时执行的规则和编译期的借用规则完全一致:

  • 同一时刻可以有多个不可变借用(borrow())
  • 同一时刻只能有一个可变借用(borrow_mut())
  • 不可变借用和可变借用不能同时存在
rust
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 内部的借用计数会自动更新。

rust
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,让你有机会处理错误。

rust
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 提供内部可变性。

rust
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 就派上用场了。

rust
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 的常用方法 ​

rust
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。

rust
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) ​

rust
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>> 实现观察者模式。

rust
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。