RefCell<T> and the Interior Mutability Pattern - The Rust Programming Language

`RefCell<T>` 与内部可变性模式

内部可变性（Interior mutability） 是 Rust 中的一种设计模式，它允许你在拥有不可变引用的情况下修改数据；通常来说，这种行为是被借用规则禁止的。为了修改数据，该模式在数据结构内部使用了 unsafe 代码，以绕过 Rust 通常对可变性和借用施加的规则。非安全代码向编译器表明我们将手动检查规则，而不是依赖编译器为我们检查；我们将在第 20 章更详细地讨论非安全代码。

只有当我们能够确保运行时遵循借用规则时，才能使用那些使用了内部可变性模式的类型，尽管编译器无法保证这一点。相关的 unsafe 代码被封装在一个安全的 API 中，而外部类型仍然是不可变的。

让我们通过考察遵循内部可变性模式的 RefCell<T> 类型来探索这个概念。

在运行时强制执行借用规则：`RefCell<T>`

与 Rc<T> 不同，RefCell<T> 类型代表其持有的数据拥有单重所有权。那么 RefCell<T> 与像 Box<T> 这样的类型有什么不同呢？回顾你在第 4 章中学到的借用规则：

在任何给定时间，你可以拥有要么一个可变引用，要么任意数量的不可变引用（两者不能同时拥有）。
引用必须总是有效的。

对于引用和 Box<T>，借用规则的不变性在编译时强制执行。而对于 RefCell<T>，这些不变性是在 运行时 强制执行的。对于引用，如果你违反了这些规则，你会得到一个编译错误。对于 RefCell<T>，如果你违反了这些规则，你的程序将会 panic 并退出。

在编译时检查借用规则的优点是错误会在开发过程的早期被捕获，而且对运行时性能没有影响，因为所有的分析都在之前完成。由于这些原因，在大多数情况下，编译时检查借用规则是最佳选择，这也是 Rust 的默认行为。

相比之下，在运行时检查借用规则的优点是允许某些内存安全的场景，而这些场景会被编译时检查所禁止。静态分析，例如 Rust 编译器，本质上是保守的。代码的一些属性是不可能通过分析代码来检测的：最著名的例子是停机问题（Halting Problem），这超出了本书的范围，但这是一个值得研究的有趣话题。

因为某些分析是不可能的，如果 Rust 编译器无法确定代码遵守所有权规则，它可能会拒绝一个正确的程序；从这个意义上说，它是保守的。如果 Rust 接受了错误的程序，用户将无法信任 Rust 的保证。然而，如果 Rust 拒绝了一个正确的程序，程序员会感到不便，但不会发生灾难性的情况。当你确定代码遵循借用规则但编译器无法理解和保证时，RefCell<T> 类型就很有用。

与 Rc<T> 类似，RefCell<T> 仅用于单线程场景，如果你尝试在多线程上下文中使用它，将会得到编译时错误。我们将在第 16 章讨论如何在多线程程序中获得 RefCell<T> 的功能。

这里总结了选择 Box<T>、Rc<T> 或 RefCell<T> 的原因：

Rc<T> 允许多个所有者拥有相同数据；Box<T> 和 RefCell<T> 拥有单重所有权。
Box<T> 允许在编译时检查的不可变或可变借用；Rc<T> 仅允许在编译时检查的不可变借用；RefCell<T> 允许在运行时检查的不可变或可变借用。
由于 RefCell<T> 允许在运行时检查的可变借用，即使 RefCell<T> 是不可变的，你也可以修改其内部的值。

修改一个不可变值内部的值就是 内部可变性 模式。让我们看一个内部可变性有用的情况，并研究它是如何实现的。

内部可变性：对不可变值进行可变借用

借用规则的一个结果是，当你有一个不可变值时，你不能可变地借用它。例如，这段代码将无法编译：

fn main() {
    let x = 5;
    let y = &mut x;
}

如果你试图编译这段代码，你会得到如下错误：

$ cargo run
   Compiling borrowing v0.1.0 (file:///projects/borrowing)
error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
 --> src/main.rs:3:13
  |
3 |     let y = &mut x;
  |             ^^^^^^ cannot borrow as mutable
  |
help: consider changing this to be mutable
  |
2 |     let mut x = 5;
  |         +++

For more information about this error, try `rustc --explain E0596`.
error: could not compile `borrowing` (bin "borrowing") due to 1 previous error

然而，在某些情况下，允许一个值在其方法中修改自身，但在其他代码看来是不可变的，这会很有用。值的方法之外的代码将无法修改该值。使用 RefCell<T> 是一种实现内部可变性的方法，但 RefCell<T> 并没有完全绕过借用规则：编译器中的借用检查器允许这种内部可变性，而借用规则改在运行时检查。如果你违反了规则，你会得到一个 panic! 而不是编译错误。

让我们来看一个实际的例子，其中我们可以使用 RefCell<T> 修改不可变值，并看看为什么这很有用。

内部可变性的用例：模拟对象

在测试过程中，程序员有时会使用一种类型来代替另一种类型，以便观察特定的行为并断言其实现正确。这种占位符类型称为 测试替身（test double）。可以将其理解为电影制作中的特技替身，某人替补演员完成一个特别棘手的场景。在运行测试时，测试替身代替其他类型。模拟对象（Mock objects） 是特定类型的测试替身，它记录测试期间发生的事情，以便你可以断言执行了正确的操作。

Rust 没有像其他语言那样意义上的对象，并且 Rust 标准库中也没有内置模拟对象功能，不像其他一些语言那样。然而，你绝对可以创建一个结构体，其作用与模拟对象相同。

以下是我们将要测试的场景：我们将创建一个库，该库根据当前值与最大值的接近程度来跟踪一个值，并根据接近程度发送消息。例如，这个库可以用来跟踪用户允许进行的 API 调用数量的配额。

我们的库只提供跟踪值与最大值接近程度以及何时发送何种消息的功能。使用我们库的应用程序需要提供发送消息的机制：应用程序可以在应用程序内部显示消息、发送电子邮件、发送短信或其他方式。库不需要知道这些细节。它只需要实现我们提供的一个名为 Messenger 的 trait。列表 15-20 展示了库的代码。

文件名：src/lib.rs

pub trait Messenger {
    fn send(&self, msg: &str);
}

pub struct LimitTracker<'a, T: Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T>
where
    T: Messenger,
{
    pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
        LimitTracker {
            messenger,
            value: 0,
            max,
        }
    }

    pub fn set_value(&mut self, value: usize) {
        self.value = value;

        let percentage_of_max = self.value as f64 / self.max as f64;

        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
            self.messenger
                .send("Urgent warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger
                .send("Warning: You've used up over 75% of your quota!");
        }
    }
}

列表 15-20：一个库，用于跟踪值与最大值的接近程度，并在达到特定级别时发出警告

这段代码的一个重要部分是 Messenger trait 有一个名为 send 的方法，该方法接受一个对 self 的不可变引用和消息文本。这个 trait 是我们的模拟对象需要实现的接口，以便模拟对象可以像真实对象一样使用。另一个重要部分是我们要测试 LimitTracker 上 set_value 方法的行为。我们可以改变传入的 value 参数，但 set_value 不返回任何值供我们进行断言。我们希望能够说，如果我们创建了一个带有实现 Messenger trait 的对象和特定 max 值的 LimitTracker，当我们传入不同的 value 值时，信使会被告知发送适当的消息。

我们需要一个模拟对象，它在调用 send 时不会发送电子邮件或短信，而只会记录被告知发送的消息。我们可以创建一个新的模拟对象实例，创建一个使用该模拟对象的 LimitTracker，调用 LimitTracker 上的 set_value 方法，然后检查模拟对象是否包含了我们预期的消息。列表 15-21 展示了实现一个完成此任务的模拟对象的尝试，但借用检查器不允许这样做。

文件名：src/lib.rs

pub trait Messenger {
    fn send(&self, msg: &str);
}

pub struct LimitTracker<'a, T: Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T>
where
    T: Messenger,
{
    pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
        LimitTracker {
            messenger,
            value: 0,
            max,
        }
    }

    pub fn set_value(&mut self, value: usize) {
        self.value = value;

        let percentage_of_max = self.value as f64 / self.max as f64;

        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
            self.messenger
                .send("Urgent warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger
                .send("Warning: You've used up over 75% of your quota!");
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    struct MockMessenger {
        sent_messages: Vec<String>,
    }

    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger {
                sent_messages: vec![],
            }
        }
    }

    impl Messenger for MockMessenger {
        fn send(&self, message: &str) {
            self.sent_messages.push(String::from(message));
        }
    }

    #[test]
    fn it_sends_an_over_75_percent_warning_message() {
        let mock_messenger = MockMessenger::new();
        let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);

        limit_tracker.set_value(80);

        assert_eq!(mock_messenger.sent_messages.len(), 1);
    }
}

列表 15-21：尝试实现一个 MockMessenger，但被借用检查器禁止

这段测试代码定义了一个 MockMessenger 结构体，该结构体有一个 sent_messages 字段，类型是 Vec<String>，用于跟踪被告知发送的消息。我们还定义了一个关联函数 new，以便方便地创建以空消息列表开始的新 MockMessenger 值。然后我们为 MockMessenger 实现了 Messenger trait，这样我们就可以将 MockMessenger 提供给 LimitTracker。在 send 方法的定义中，我们将作为参数传入的消息存储到 MockMessenger 的 sent_messages 列表中。

在测试中，我们测试当 LimitTracker 被告知将 value 设置为大于 max 值 75% 的值时会发生什么。首先，我们创建一个新的 MockMessenger，它将以一个空消息列表开始。然后我们创建一个新的 LimitTracker，并给它一个对新 MockMessenger 的引用和一个 max 值 100。我们在 LimitTracker 上调用 set_value 方法，值为 80，这大于 100 的 75%。然后我们断言 MockMessenger 正在跟踪的消息列表现在应该有一条消息。

然而，这个测试有一个问题，如下所示：

$ cargo test
   Compiling limit-tracker v0.1.0 (file:///projects/limit-tracker)
error[E0596]: cannot borrow `self.sent_messages` as mutable, as it is behind a `&` reference
  --> src/lib.rs:58:13
   |
58 |             self.sent_messages.push(String::from(message));
   |             ^^^^^^^^^^^^^^^^^^ `self` is a `&` reference, so the data it refers to cannot be borrowed as mutable
   |
help: consider changing this to be a mutable reference in the `impl` method and the `trait` definition
   |
2  ~     fn send(&mut self, msg: &str);
3  | }
...
56 |     impl Messenger for MockMessenger {
57 ~         fn send(&mut self, message: &str) {
   |

For more information about this error, try `rustc --explain E0596`.
error: could not compile `limit-tracker` (lib test) due to 1 previous error
warning: build failed, waiting for other jobs to finish...

我们无法修改 MockMessenger 来跟踪消息，因为 send 方法接受一个对 self 的不可变引用。我们也不能采纳错误文本中建议的使用 &mut self 的做法，无论是在 impl 方法还是在 trait 定义中。我们不希望仅仅为了测试而改变 Messenger trait。相反，我们需要找到一种方法，使我们的测试代码能够与现有设计正确协同工作。

在这种情况下，内部可变性可以派上用场！我们将 sent_messages 存储在一个 RefCell<T> 中，这样 send 方法就能够修改 sent_messages 来存储我们看到的消息。列表 15-22 展示了如何实现这一点。

文件名：src/lib.rs

pub trait Messenger {
    fn send(&self, msg: &str);
}

pub struct LimitTracker<'a, T: Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T>
where
    T: Messenger,
{
    pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
        LimitTracker {
            messenger,
            value: 0,
            max,
        }
    }

    pub fn set_value(&mut self, value: usize) {
        self.value = value;

        let percentage_of_max = self.value as f64 / self.max as f64;

        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
            self.messenger
                .send("Urgent warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger
                .send("Warning: You've used up over 75% of your quota!");
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::cell::RefCell;

    struct MockMessenger {
        sent_messages: RefCell<Vec<String>>,
    }

    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger {
                sent_messages: RefCell::new(vec![]),
            }
        }
    }

    impl Messenger for MockMessenger {
        fn send(&self, message: &str) {
            self.sent_messages.borrow_mut().push(String::from(message));
        }
    }

    #[test]
    fn it_sends_an_over_75_percent_warning_message() {
        // --snip--
        let mock_messenger = MockMessenger::new();
        let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);

        limit_tracker.set_value(80);

        assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
    }
}

列表 15-22：使用 RefCell<T> 修改外部被认为是不可变的值内部的值

sent_messages 字段现在是 RefCell<Vec<String>> 类型，而不是 Vec<String>。在 new 函数中，我们创建了一个围绕空向量的新 RefCell<Vec<String>> 实例。

对于 send 方法的实现，第一个参数仍然是对 self 的不可变借用，这与 trait 定义相匹配。我们对 self.sent_messages 中的 RefCell<Vec<String>> 调用 borrow_mut，以获得对 RefCell<Vec<String>> 内部值的可变引用，即向量。然后，我们就可以对向量的可变引用调用 push，以跟踪测试期间发送的消息。

我们还需要做的最后一个改变是在断言中：为了查看内部向量中有多少项，我们对 RefCell<Vec<String>> 调用 borrow，以获得对向量的不可变引用。

既然你已经了解了如何使用 RefCell<T>，让我们深入探讨它的工作原理！

使用 `RefCell<T>` 在运行时跟踪借用

在创建不可变引用和可变引用时，我们分别使用 & 和 &mut 语法。对于 RefCell<T>，我们使用 borrow 和 borrow_mut 方法，这些方法是 RefCell<T> 的安全 API 的一部分。borrow 方法返回智能指针类型 Ref<T>，而 borrow_mut 返回智能指针类型 RefMut<T>。这两种类型都实现了 Deref，因此我们可以像对待常规引用一样对待它们。

RefCell<T> 跟踪当前有多少个 Ref<T> 和 RefMut<T> 智能指针处于活动状态。每当我们调用 borrow 时，RefCell<T> 就会增加其活动不可变借用的计数。当一个 Ref<T> 值超出作用域时，不可变借用的计数就会减少 1。就像编译时借用规则一样，RefCell<T> 允许我们在任何时候拥有多个不可变借用或一个可变借用。

如果我们试图违反这些规则，我们不会像使用引用那样得到编译错误，而是 RefCell<T> 的实现会在运行时 panic。列表 15-23 展示了对列表 15-22 中 send 实现的修改。我们故意尝试在同一作用域内创建两个活动的可变借用，以说明 RefCell<T> 在运行时阻止我们这样做。

文件名：src/lib.rs

pub trait Messenger {
    fn send(&self, msg: &str);
}

pub struct LimitTracker<'a, T: Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T>
where
    T: Messenger,
{
    pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
        LimitTracker {
            messenger,
            value: 0,
            max,
        }
    }

    pub fn set_value(&mut self, value: usize) {
        self.value = value;

        let percentage_of_max = self.value as f64 / self.max as f64;

        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
            self.messenger
                .send("Urgent warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger
                .send("Warning: You've used up over 75% of your quota!");
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::cell::RefCell;

    struct MockMessenger {
        sent_messages: RefCell<Vec<String>>,
    }

    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger {
                sent_messages: RefCell::new(vec![]),
            }
        }
    }

    impl Messenger for MockMessenger {
        fn send(&self, message: &str) {
            let mut one_borrow = self.sent_messages.borrow_mut();
            let mut two_borrow = self.sent_messages.borrow_mut();

            one_borrow.push(String::from(message));
            two_borrow.push(String::from(message));
        }
    }

    #[test]
    fn it_sends_an_over_75_percent_warning_message() {
        let mock_messenger = MockMessenger::new();
        let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);

        limit_tracker.set_value(80);

        assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
    }
}

列表 15-23：在同一作用域创建两个可变引用，查看 RefCell<T> 如何引发 panic

我们为 borrow_mut 返回的 RefMut<T> 智能指针创建了一个变量 one_borrow。然后我们在变量 two_borrow 中以相同的方式创建了另一个可变借用。这在同一作用域内产生了两个可变引用，这是不允许的。当我们运行库的测试时，列表 15-23 中的代码将编译成功，但测试会失败：

$ cargo test
   Compiling limit-tracker v0.1.0 (file:///projects/limit-tracker)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.91s
     Running unittests src/lib.rs (target/debug/deps/limit_tracker-e599811fa246dbde)

running 1 test
test tests::it_sends_an_over_75_percent_warning_message ... FAILED

failures:

---- tests::it_sends_an_over_75_percent_warning_message stdout ----

thread 'tests::it_sends_an_over_75_percent_warning_message' panicked at src/lib.rs:60:53:
already borrowed: BorrowMutError
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::it_sends_an_over_75_percent_warning_message

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--lib`

注意代码 panic 了，消息是 already borrowed: BorrowMutError。这就是 RefCell<T> 在运行时处理借用规则违反的方式。

选择在运行时而不是编译时捕获借用错误（就像我们这里所做的）意味着你可能会在开发过程的后期才发现代码中的错误：可能要到代码部署到生产环境时才能发现。此外，由于在运行时而不是编译时跟踪借用，你的代码会产生很小的运行时性能开销。然而，使用 RefCell<T> 使得编写一个模拟对象成为可能，该对象可以在你将其用于只允许不可变值的上下文时修改自身来跟踪它看到的消息。尽管存在权衡，你还是可以使用 RefCell<T> 来获得比常规引用更多的功能。

结合 `Rc<T>` 和 `RefCell<T>` 允许多个所有者拥有可变数据

RefCell<T> 的一个常见用法是与 Rc<T> 结合使用。回顾一下，Rc<T> 允许你拥有某些数据的多个所有者，但它只提供对该数据的不可变访问。如果你有一个持有 RefCell<T> 的 Rc<T>，你就可以获得一个可以有多个所有者并且可以修改的值！

例如，回顾列表 15-18 中的 Cons 列表示例，我们使用 Rc<T> 允许多个列表共享另一个列表的所有权。由于 Rc<T> 只持有不可变值，一旦创建了列表，我们就无法更改其中的任何值。让我们加入 RefCell<T>，利用其改变列表中值的能力。列表 15-24 展示了通过在 Cons 定义中使用 RefCell<T>，我们可以修改存储在所有列表中的值。

文件名：src/main.rs

#[derive(Debug)]
enum List {
    Cons(Rc<RefCell<i32>>, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::cell::RefCell;
use std::rc::Rc;

fn main() {
    let value = Rc::new(RefCell::new(5));

    let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));

    let b = Cons(Rc::new(RefCell::new(3)), Rc::clone(&a));
    let c = Cons(Rc::new(RefCell::new(4)), Rc::clone(&a));

    *value.borrow_mut() += 10;

    println!("a after = {a:?}");
    println!("b after = {b:?}");
    println!("c after = {c:?}");
}

列表 15-24：使用 Rc<RefCell<i32>> 创建一个可以修改的 List

我们创建一个 Rc<RefCell<i32>> 的实例，并将其存储在一个名为 value 的变量中，以便之后可以直接访问它。然后我们在 a 中创建一个 List，其 Cons 变体持有 value。我们需要克隆 value，以便 a 和 value 都拥有内部 5 值的所有权，而不是将所有权从 value 转移到 a 或让 a 从 value 借用。

我们将列表 a 包装在一个 Rc<T> 中，以便当我们创建列表 b 和 c 时，它们都可以引用 a，这与我们在列表 15-18 中的做法相同。

在我们创建了 a、b 和 c 中的列表之后，我们想将 value 中的值增加 10。我们通过对 value 调用 borrow_mut 来实现这一点，这使用了我们在第 5 章 “-> 运算符在哪里？” 中讨论的自动解引用功能，将 Rc<T> 解引用到内部的 RefCell<T> 值。borrow_mut 方法返回一个 RefMut<T> 智能指针，我们对其使用解引用运算符并改变内部值。

当我们打印 a、b 和 c 时，我们可以看到它们都拥有修改后的值 15，而不是 5：

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.63s
     Running `target/debug/cons-list`
a after = Cons(RefCell { value: 15 }, Nil)
b after = Cons(RefCell { value: 3 }, Cons(RefCell { value: 15 }, Nil))
c after = Cons(RefCell { value: 4 }, Cons(RefCell { value: 15 }, Nil))

这个技巧非常巧妙！通过使用 RefCell<T>，我们拥有一个外部不可变的 List 值。但我们可以使用 RefCell<T> 提供访问其内部可变性的方法，以便在需要时修改数据。运行时对借用规则的检查保护我们免受数据竞争的影响，有时为了数据结构的这种灵活性而牺牲一点速度是值得的。请注意，RefCell<T> 不适用于多线程代码！Mutex<T> 是 RefCell<T> 的线程安全版本，我们将在第 16 章讨论 Mutex<T>。

Rust 程序设计语言

RefCell<T> 与内部可变性模式

在运行时强制执行借用规则：RefCell<T>

内部可变性：对不可变值进行可变借用

内部可变性的用例：模拟对象

使用 RefCell<T> 在运行时跟踪借用

结合 Rc<T> 和 RefCell<T> 允许多个所有者拥有可变数据

`RefCell<T>` 与内部可变性模式

在运行时强制执行借用规则：`RefCell<T>`

使用 `RefCell<T>` 在运行时跟踪借用

结合 `Rc<T>` 和 `RefCell<T>` 允许多个所有者拥有可变数据