内部可变性模式 ​

面试题 ​

什么是 Rust 的内部可变性(interior mutability)?它是如何绕过编译期借用规则的?请举例说明常见的内部可变性类型。

考察意图 ​

内部可变性是 Rust 类型系统中看似矛盾但设计精巧的机制——在持有不可变引用 &T 的情况下修改内部数据。面试官想看候选人能否解释这个机制的底层原理(UnsafeCell)和实际使用场景。

答题要点 ​

什么是内部可变性 ​

rust
use std::cell::RefCell;

fn main() {
    // 正常的借用规则:&T 不能修改数据
    let x = 5;
    // let r = &x;
    // *r = 10;  // 编译错误:不能通过不可变引用修改

    // 内部可变性:通过 &T 修改内部数据
    let data = RefCell::new(5);
    // data 本身是不可变的,但可以修改其内部值
    *data.borrow_mut() = 10;
    println!("修改后: {}", data.borrow());

    // 这不是绕过安全性——借用检查被推迟到运行时
    // 运行时仍然遵循"多个不可变 OR 一个可变"的规则
}

UnsafeCell:内部可变性的基础 ​

rust
// 所有内部可变性类型的底层都是 UnsafeCell<T>
// 它是唯一一个可以从 &T 获得 *mut T 的类型
// Cell、RefCell、Mutex、RwLock 都基于 UnsafeCell

// UnsafeCell 的简化定义:
// #[repr(transparent)]
// pub struct UnsafeCell<T: ?Sized> {
//     value: T,
// }
// impl<T> UnsafeCell<T> {
//     pub fn get(&self) -> *mut T { ... }  // &self → *mut T
// }

// 直接使用 UnsafeCell 需要 unsafe
// 安全的包装:Cell、RefCell、Mutex 等

fn main() {
    println!("UnsafeCell 是所有内部可变性类型的基础");
}

内部可变性类型对比 ​

类型线程安全检查方式适用类型开销
Cell<T>否无(直接替换)Copy 类型最低
RefCell<T>否运行时借用检查任意类型借用计数
Mutex<T>是互斥锁任意类型锁竞争
RwLock<T>是读写锁任意类型锁竞争
AtomicXxx是原子操作整数/布尔/指针原子指令

Cell<T> ​

rust
use std::cell::Cell;

fn main() {
    // Cell:通过替换整个值实现可变性
    // 只适用于 Copy 类型(因为 get 返回的是值的拷贝)

    let counter = Cell::new(0);

    // set 替换整个值
    counter.set(counter.get() + 1);
    counter.set(counter.get() + 1);
    println!("计数: {}", counter.get());  // 2

    // 不能获取内部引用(因为随时可能被替换)
    // 只能 get(拷贝出来)和 set(替换进去)

    // 实际用途:计数器、标志位等
    struct Logger {
        log_count: Cell<u32>,  // 即使 &self 也可以计数
    }

    impl Logger {
        fn log(&self, msg: &str) {
            // &self 方法中修改 log_count
            self.log_count.set(self.log_count.get() + 1);
            println!("[{}] {}", self.log_count.get(), msg);
        }
    }

    let logger = Logger { log_count: Cell::new(0) };
    logger.log("启动");
    logger.log("运行中");
    println!("总日志数: {}", logger.log_count.get());
}

RefCell<T> ​

rust
use std::cell::RefCell;

// 缓存模式:计算结果的延迟缓存
struct CachedComputer {
    input: Vec<i32>,
    cache: RefCell<Option<i32>>,  // 内部可变性缓存
}

impl CachedComputer {
    fn new(input: Vec<i32>) -> Self {
        CachedComputer {
            input,
            cache: RefCell::new(None),
        }
    }

    // &self 方法可以修改 cache
    fn compute(&self) -> i32 {
        let cached = self.cache.borrow().clone();
        if let Some(result) = cached {
            return result;
        }

        // 计算(模拟耗时操作)
        let result: i32 = self.input.iter().sum();
        *self.cache.borrow_mut() = Some(result);
        result
    }
}

fn main() {
    let computer = CachedComputer::new(vec![1, 2, 3, 4, 5]);

    // 第一次调用:计算并缓存
    println!("结果: {}", computer.compute());
    // 第二次调用:使用缓存
    println!("缓存: {}", computer.compute());

    // RefCell 的运行时检查
    let data = RefCell::new(42);
    let r1 = data.borrow();       // 不可变借用
    let r2 = data.borrow();       // 可以多个不可变借用
    println!("{} {}", r1, r2);
    drop(r1);
    drop(r2);

    let mut r3 = data.borrow_mut();  // 可变借用
    *r3 = 100;
    drop(r3);

    // 违反规则会 panic:
    // let r4 = data.borrow();
    // let r5 = data.borrow_mut();  // panic!
}

常见追问 ​

追问一:内部可变性违反了 Rust 的安全保证吗?

没有。内部可变性只是将借用检查从编译期推迟到运行时(RefCell)或使用线程安全的同步原语(Mutex)。安全性保证仍然存在——RefCell 在运行时违规会 panic,Mutex 通过锁保证互斥。

追问二:OnceCell 和 LazyCell 是内部可变性吗?

是的。OnceCell 允许值只被初始化一次,之后不可变。LazyCell 是延迟初始化版本。它们内部基于 UnsafeCell。标准库中 OnceLock 和 LazyLock 是线程安全版本。

追问三:为什么不总是用 RefCell?

因为 RefCell 有运行时开销(维护借用状态),且违规会 panic 而非编译错误。编译期检查更安全、零开销。RefCell 只在编译期规则确实过于限制时才使用。

基本示例 ​

rust
use std::cell::{Cell, RefCell};

// 观察者模式:多个观察者共享一个可变的事件列表
struct EventBus {
    events: RefCell<Vec<String>>,
    event_count: Cell<u32>,
}

impl EventBus {
    fn new() -> Self {
        EventBus {
            events: RefCell::new(Vec::new()),
            event_count: Cell::new(0),
        }
    }

    fn emit(&self, event: &str) {
        self.events.borrow_mut().push(event.to_string());
        self.event_count.set(self.event_count.get() + 1);
    }

    fn get_events(&self) -> Vec<String> {
        self.events.borrow().clone()
    }

    fn count(&self) -> u32 {
        self.event_count.get()
    }
}

fn main() {
    let bus = EventBus::new();

    // 所有操作都通过 &self(不可变引用)
    bus.emit("user_login");
    bus.emit("page_view");
    bus.emit("button_click");

    println!("事件数: {}", bus.count());
    println!("事件列表: {:?}", bus.get_events());
}

常见问题 ​

问题一:Cell 和 RefCell 怎么选?

如果值是 Copy 类型且只需要 get/set,用 Cell(更高效)。如果需要引用访问内部数据或值不是 Copy 的,用 RefCell。

问题二:多线程中怎么实现内部可变性?

用 Mutex<T>、RwLock<T> 或 AtomicXxx。Arc<Mutex<T>> 是多线程共享可变数据的标准模式。

适用场景 ​

  • 缓存模式:在 &self 方法中缓存计算结果
  • 计数器:在不可变上下文中维护计数
  • 观察者模式:共享的事件列表
  • Mock 测试:在测试中记录方法调用

注意事项 ​

  • 优先使用编译期借用检查
  • RefCell 违规会 panic,不是编译错误
  • Cell 只适用于 Copy 类型
  • Cell 和 RefCell 不是线程安全的
  • 多线程用 Mutex/RwLock/Atomic
  • 所有内部可变性都基于 UnsafeCell

总结 ​

内部可变性允许通过 &T 修改内部数据,底层基于 UnsafeCell。Cell<T> 通过值替换实现,适合 Copy 类型,开销最低。RefCell<T> 通过运行时借用检查实现,支持引用访问,违规会 panic。多线程版本有 Mutex<T>(互斥锁)、RwLock<T>(读写锁)和 AtomicXxx(原子操作)。内部可变性不违反安全保证——检查只是从编译期推迟到运行时。常见模式:缓存、计数器、观察者。应优先使用编译期检查,只有在确实需要时才使用内部可变性。