RefCell 和内部可变性模式

ch15-05-interior-mutability.md
commit 74edb8dfe07edf8fdae49c6385c72840c07dd18f

内部可变性（Interior mutability）是 Rust 中的一个设计模式，它允许你即使在有不可变引用时也可以改变数据，这通常是借用规则所不允许的。为了改变数据，该模式在数据结构中使用 unsafe 代码来模糊 Rust 通常的可变性和借用规则。我们还未讲到不安全代码；第十九章会学习它们。当可以确保代码在运行时会遵守借用规则，即使编译器不能保证的情况，可以选择使用那些运用内部可变性模式的类型。所涉及的 unsafe 代码将被封装进安全的 API 中，而外部类型仍然是不可变的。

让我们通过遵循内部可变性模式的 RefCell 类型来开始探索。

通过 RefCell 在运行时检查借用规则

不同于 Rc，RefCell 代表其数据的唯一的所有权。那么是什么让 RefCell 不同于像 Box 这样的类型呢？回忆一下第四章所学的借用规则：

  • 在任意给定时刻，只能拥有一个可变引用或任意数量的不可变引用 之一（而不是两者）。
  • 引用必须总是有效的。

对于引用和 Box，借用规则的不可变性作用于编译时。对于 RefCell，这些不可变性作用于 运行时。对于引用，如果违反这些规则，会得到一个编译错误。而对于 RefCell，如果违反这些规则程序会 panic 并退出。

在编译时检查借用规则的优势是这些错误将在开发过程的早期被捕获，同时对运行时没有性能影响，因为所有的分析都提前完成了。为此，在编译时检查借用规则是大部分情况的最佳选择，这也正是其为何是 Rust 的默认行为。

相反在运行时检查借用规则的好处则是允许出现特定内存安全的场景，而它们在编译时检查中是不允许的。静态分析，正如 Rust 编译器，是天生保守的。但代码的一些属性不可能通过分析代码发现：其中最著名的就是 停机问题（Halting Problem），这超出了本书的范畴，不过如果你感兴趣的话这是一个值得研究的有趣主题。

因为一些分析是不可能的，如果 Rust 编译器不能通过所有权规则编译，它可能会拒绝一个正确的程序；从这种角度考虑它是保守的。如果 Rust 接受不正确的程序，那么用户也就不会相信 Rust 所做的保证了。然而，如果 Rust 拒绝正确的程序，虽然会给程序员带来不便，但不会带来灾难。RefCell 正是用于当你确信代码遵守借用规则，而编译器不能理解和确定的时候。

类似于 Rc，RefCell 只能用于单线程场景。如果尝试在多线程上下文中使用RefCell，会得到一个编译错误。第十六章会介绍如何在多线程程序中使用 RefCell 的功能。

如下为选择 Box，Rc 或 RefCell 的理由：

  • Rc 允许相同数据有多个所有者；Box 和 RefCell 有单一所有者。
  • Box 允许在编译时执行不可变或可变借用检查；Rc仅允许在编译时执行不可变借用检查；RefCell 允许在运行时执行不可变或可变借用检查。
  • 因为 RefCell 允许在运行时执行可变借用检查，所以我们可以在即便 RefCell 自身是不可变的情况下修改其内部的值。

在不可变值内部改变值就是 内部可变性 模式。让我们看看何时内部可变性是有用的，并讨论这是如何成为可能的。

内部可变性：不可变值的可变借用

借用规则的一个推论是当有一个不可变值时，不能可变地借用它。例如，如下代码不能编译：

  1. fn main() {
  2.     let x = 5;
  3.     let y = &mut x;
  4. }

如果尝试编译，会得到如下错误：

  1. $ cargo run
  2.    Compiling borrowing v0.1.0 (file:///projects/borrowing)
  3. error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
  4.  --> src/main.rs:3:13
  5.   |
  6. 2 |     let x = 5;
  7.   |         - help: consider changing this to be mutable: `mut x`
  8. 3 |     let y = &mut x;
  9.   |             ^^^^^^ cannot borrow as mutable
  11. For more information about this error, try `rustc --explain E0596`.
  12. error: could not compile `borrowing` due to previous error

然而，特定情况下，令一个值在其方法内部能够修改自身，而在其他代码中仍视为不可变，是很有用的。值方法外部的代码就不能修改其值了。RefCell 是一个获得内部可变性的方法。RefCell 并没有完全绕开借用规则，编译器中的借用检查器允许内部可变性并相应地在运行时检查借用规则。如果违反了这些规则，会出现 panic 而不是编译错误。

让我们通过一个实际的例子来探索何处可以使用 RefCell 来修改不可变值并看看为何这么做是有意义的。

内部可变性的用例：mock 对象

测试替身（test double）是一个通用编程概念，它代表一个在测试中替代某个类型的类型。mock 对象 是特定类型的测试替身，它们记录测试过程中发生了什么以便可以断言操作是正确的。

虽然 Rust 中的对象与其他语言中的对象并不是一回事，Rust 也没有像其他语言那样在标准库中内建 mock 对象功能，不过我们确实可以创建一个与 mock 对象有着相同功能的结构体。

如下是一个我们想要测试的场景：我们在编写一个记录某个值与最大值的差距的库，并根据当前值与最大值的差距来发送消息。例如，这个库可以用于记录用户所允许的 API 调用数量限额。

该库只提供记录与最大值的差距，以及何种情况发送什么消息的功能。使用此库的程序则期望提供实际发送消息的机制：程序可以选择记录一条消息、发送 email、发送短信等等。库本身无需知道这些细节；只需实现其提供的 Messenger trait 即可。示例 15-20 展示了库代码：

文件名: src/lib.rs

  1. pub trait Messenger {
  2.     fn send(&self, msg: &str);
  3. }
  5. pub struct LimitTracker<'a, T: Messenger> {
  6.     messenger: &'a T,
  7.     value: usize,
  8.     max: usize,
  9. }
  11. impl<'a, T> LimitTracker<'a, T>
  12. where
  13.     T: Messenger,
  14. {
  15.     pub fn new(messenger: &T, max: usize) -> LimitTracker<T> {
  16.         LimitTracker {
  17.             messenger,
  18.             value: 0,
  19.             max,
  20.         }
  21.     }
  23.     pub fn set_value(&mut self, value: usize) {
  24.         self.value = value;
  26.         let percentage_of_max = self.value as f64 / self.max as f64;
  28.         if percentage_of_max >= 1.0 {
  29.             self.messenger.send("Error: You are over your quota!");
  30.         } else if percentage_of_max >= 0.9 {
  31.             self.messenger
  32.                 .send("Urgent warning: You've used up over 90% of your quota!");
  33.         } else if percentage_of_max >= 0.75 {
  34.             self.messenger
  35.                 .send("Warning: You've used up over 75% of your quota!");
  36.         }
  37.     }
  38. }

示例 15-20：一个记录某个值与最大值差距的库，并根据此值的特定级别发出警告

这些代码中一个重要部分是拥有一个方法 send 的 Messenger trait，其获取一个 self 的不可变引用和文本信息。这个 trait 是 mock 对象所需要实现的接口库，这样 mock 就能像一个真正的对象那样使用了。另一个重要的部分是我们需要测试 LimitTracker 的 set_value 方法的行为。可以改变传递的 value 参数的值，不过 set_value 并没有返回任何可供断言的值。也就是说，如果使用某个实现了 Messenger trait 的值和特定的 max 创建 LimitTracker，当传递不同 value 值时，消息发送者应被告知发送合适的消息。

我们所需的 mock 对象是，调用 send 并不实际发送 email 或消息，而是只记录信息被通知要发送了。可以新建一个 mock 对象实例，用其创建 LimitTracker，调用 LimitTracker 的 set_value 方法，然后检查 mock 对象是否有我们期望的消息。示例 15-21 展示了一个如此尝试的 mock 对象实现，不过借用检查器并不允许：

文件名: src/lib.rs

  1. pub trait Messenger {
  2.     fn send(&self, msg: &str);
  3. }
  5. pub struct LimitTracker<'a, T: Messenger> {
  6.     messenger: &'a T,
  7.     value: usize,
  8.     max: usize,
  9. }
  11. impl<'a, T> LimitTracker<'a, T>
  12. where
  13.     T: Messenger,
  14. {
  15.     pub fn new(messenger: &T, max: usize) -> LimitTracker<T> {
  16.         LimitTracker {
  17.             messenger,
  18.             value: 0,
  19.             max,
  20.         }
  21.     }
  23.     pub fn set_value(&mut self, value: usize) {
  24.         self.value = value;
  26.         let percentage_of_max = self.value as f64 / self.max as f64;
  28.         if percentage_of_max >= 1.0 {
  29.             self.messenger.send("Error: You are over your quota!");
  30.         } else if percentage_of_max >= 0.9 {
  31.             self.messenger
  32.                 .send("Urgent warning: You've used up over 90% of your quota!");
  33.         } else if percentage_of_max >= 0.75 {
  34.             self.messenger
  35.                 .send("Warning: You've used up over 75% of your quota!");
  36.         }
  37.     }
  38. }
  40. #[cfg(test)]
  41. mod tests {
  42.     use super::*;
  44.     struct MockMessenger {
  45.         sent_messages: Vec<String>,
  46.     }
  48.     impl MockMessenger {
  49.         fn new() -> MockMessenger {
  50.             MockMessenger {
  51.                 sent_messages: vec![],
  52.             }
  53.         }
  54.     }
  56.     impl Messenger for MockMessenger {
  57.         fn send(&self, message: &str) {
  58.             self.sent_messages.push(String::from(message));
  59.         }
  60.     }
  62.     #[test]
  63.     fn it_sends_an_over_75_percent_warning_message() {
  64.         let mock_messenger = MockMessenger::new();
  65.         let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
  67.         limit_tracker.set_value(80);
  69.         assert_eq!(mock_messenger.sent_messages.len(), 1);
  70.     }
  71. }

示例 15-21：尝试实现 MockMessenger，借用检查器不允许这么做

测试代码定义了一个 MockMessenger 结构体，其 sent_messages 字段为一个 String 值的 Vec 用来记录被告知发送的消息。我们还定义了一个关联函数 new 以便于新建从空消息列表开始的 MockMessenger 值。接着为 MockMessenger 实现 Messenger trait 这样就可以为 LimitTracker 提供一个 MockMessenger。在 send 方法的定义中，获取传入的消息作为参数并储存在 MockMessenger 的 sent_messages 列表中。

在测试中，我们测试了当 LimitTracker 被告知将 value 设置为超过 max 值 75% 的某个值。首先新建一个 MockMessenger，其从空消息列表开始。接着新建一个 LimitTracker 并传递新建 MockMessenger 的引用和 max 值 100。我们使用值 80 调用 LimitTracker 的 set_value 方法，这超过了 100 的 75%。接着断言 MockMessenger 中记录的消息列表应该有一条消息。

然而，这个测试是有问题的：

  1. $ cargo test
  2.    Compiling limit-tracker v0.1.0 (file:///projects/limit-tracker)
  3. error[E0596]: cannot borrow `self.sent_messages` as mutable, as it is behind a `&` reference
  4.   --> src/lib.rs:58:13
  5.    |
  6. 2  |     fn send(&self, msg: &str);
  7.    |             ----- help: consider changing that to be a mutable reference: `&mut self`
  8. ...
  9. 58 |             self.sent_messages.push(String::from(message));
  10.    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `self` is a `&` reference, so the data it refers to cannot be borrowed as mutable
  12. For more information about this error, try `rustc --explain E0596`.
  13. error: could not compile `limit-tracker` due to previous error
  14. warning: build failed, waiting for other jobs to finish...
  15. error: build failed

不能修改 MockMessenger 来记录消息，因为 send 方法获取了 self 的不可变引用。我们也不能参考错误文本的建议使用 &mut self 替代，因为这样 send 的签名就不符合 Messenger trait 定义中的签名了（可以试着这么改，看看会出现什么错误信息）。

这正是内部可变性的用武之地！我们将通过 RefCell 来储存 sent_messages，然后 send 将能够修改 sent_messages 并储存消息。示例 15-22 展示了代码：

文件名: src/lib.rs

  1. pub trait Messenger {
  2.     fn send(&self, msg: &str);
  3. }
  5. pub struct LimitTracker<'a, T: Messenger> {
  6.     messenger: &'a T,
  7.     value: usize,
  8.     max: usize,
  9. }
  11. impl<'a, T> LimitTracker<'a, T>
  12. where
  13.     T: Messenger,
  14. {
  15.     pub fn new(messenger: &T, max: usize) -> LimitTracker<T> {
  16.         LimitTracker {
  17.             messenger,
  18.             value: 0,
  19.             max,
  20.         }
  21.     }
  23.     pub fn set_value(&mut self, value: usize) {
  24.         self.value = value;
  26.         let percentage_of_max = self.value as f64 / self.max as f64;
  28.         if percentage_of_max >= 1.0 {
  29.             self.messenger.send("Error: You are over your quota!");
  30.         } else if percentage_of_max >= 0.9 {
  31.             self.messenger
  32.                 .send("Urgent warning: You've used up over 90% of your quota!");
  33.         } else if percentage_of_max >= 0.75 {
  34.             self.messenger
  35.                 .send("Warning: You've used up over 75% of your quota!");
  36.         }
  37.     }
  38. }
  40. #[cfg(test)]
  41. mod tests {
  42.     use super::*;
  43.     use std::cell::RefCell;
  45.     struct MockMessenger {
  46.         sent_messages: RefCell<Vec<String>>,
  47.     }
  49.     impl MockMessenger {
  50.         fn new() -> MockMessenger {
  51.             MockMessenger {
  52.                 sent_messages: RefCell::new(vec![]),
  53.             }
  54.         }
  55.     }
  57.     impl Messenger for MockMessenger {
  58.         fn send(&self, message: &str) {
  59.             self.sent_messages.borrow_mut().push(String::from(message));
  60.         }
  61.     }
  63.     #[test]
  64.     fn it_sends_an_over_75_percent_warning_message() {
  65.         // --snip--
  66.         let mock_messenger = MockMessenger::new();
  67.         let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
  69.         limit_tracker.set_value(80);
  71.         assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
  72.     }
  73. }

示例 15-22：使用 RefCell 能够在外部值被认为是不可变的情况下修改内部值

现在 sent_messages 字段的类型是 RefCell> 而不是 Vec。在 new 函数中新建了一个 RefCell> 实例替代空 vector。

对于 send 方法的实现，第一个参数仍为 self 的不可变借用，这是符合方法定义的。我们调用 self.sent_messages 中 RefCell 的 borrow_mut 方法来获取 RefCell 中值的可变引用，这是一个 vector。接着可以对 vector 的可变引用调用 push 以便记录测试过程中看到的消息。

最后必须做出的修改位于断言中：为了看到其内部 vector 中有多少个项，需要调用 RefCell 的 borrow 以获取 vector 的不可变引用。

现在我们见识了如何使用 RefCell，让我们研究一下它怎样工作的！

RefCell 在运行时记录借用

当创建不可变和可变引用时，我们分别使用 & 和 &mut 语法。对于 RefCell 来说，则是 borrow 和 borrow_mut 方法，这属于 RefCell 安全 API 的一部分。borrow 方法返回 Ref 类型的智能指针，borrow_mut 方法返回 RefMut 类型的智能指针。这两个类型都实现了 Deref，所以可以当作常规引用对待。

RefCell 记录当前有多少个活动的 Ref 和 RefMut 智能指针。每次调用 borrow，RefCell 将活动的不可变借用计数加一。当 Ref 值离开作用域时，不可变借用计数减一。就像编译时借用规则一样，RefCell 在任何时候只允许有多个不可变借用或一个可变借用。

如果我们尝试违反这些规则，相比引用时的编译时错误，RefCell 的实现会在运行时出现 panic。示例 15-23 展示了对示例 15-22 中 send 实现的修改，这里我们故意尝试在相同作用域创建两个可变借用以便演示 RefCell 不允许我们在运行时这么做：

文件名: src/lib.rs

  1. pub trait Messenger {
  2.     fn send(&self, msg: &str);
  3. }
  5. pub struct LimitTracker<'a, T: Messenger> {
  6.     messenger: &'a T,
  7.     value: usize,
  8.     max: usize,
  9. }
  11. impl<'a, T> LimitTracker<'a, T>
  12. where
  13.     T: Messenger,
  14. {
  15.     pub fn new(messenger: &T, max: usize) -> LimitTracker<T> {
  16.         LimitTracker {
  17.             messenger,
  18.             value: 0,
  19.             max,
  20.         }
  21.     }
  23.     pub fn set_value(&mut self, value: usize) {
  24.         self.value = value;
  26.         let percentage_of_max = self.value as f64 / self.max as f64;
  28.         if percentage_of_max >= 1.0 {
  29.             self.messenger.send("Error: You are over your quota!");
  30.         } else if percentage_of_max >= 0.9 {
  31.             self.messenger
  32.                 .send("Urgent warning: You've used up over 90% of your quota!");
  33.         } else if percentage_of_max >= 0.75 {
  34.             self.messenger
  35.                 .send("Warning: You've used up over 75% of your quota!");
  36.         }
  37.     }
  38. }
  40. #[cfg(test)]
  41. mod tests {
  42.     use super::*;
  43.     use std::cell::RefCell;
  45.     struct MockMessenger {
  46.         sent_messages: RefCell<Vec<String>>,
  47.     }
  49.     impl MockMessenger {
  50.         fn new() -> MockMessenger {
  51.             MockMessenger {
  52.                 sent_messages: RefCell::new(vec![]),
  53.             }
  54.         }
  55.     }
  57.     impl Messenger for MockMessenger {
  58.         fn send(&self, message: &str) {
  59.             let mut one_borrow = self.sent_messages.borrow_mut();
  60.             let mut two_borrow = self.sent_messages.borrow_mut();
  62.             one_borrow.push(String::from(message));
  63.             two_borrow.push(String::from(message));
  64.         }
  65.     }
  67.     #[test]
  68.     fn it_sends_an_over_75_percent_warning_message() {
  69.         let mock_messenger = MockMessenger::new();
  70.         let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
  72.         limit_tracker.set_value(80);
  74.         assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
  75.     }
  76. }

示例 15-23：在同一作用域中创建两个可变引用并观察 RefCell panic

这里为 borrow_mut 返回的 RefMut 智能指针创建了 one_borrow 变量。接着用相同的方式在变量 two_borrow 创建了另一个可变借用。这会在相同作用域中创建两个可变引用，这是不允许的。当运行库的测试时，示例 15-23 编译时不会有任何错误，不过测试会失败：

  1. $ cargo test
  2.    Compiling limit-tracker v0.1.0 (file:///projects/limit-tracker)
  3.     Finished test [unoptimized + debuginfo] target(s) in 0.91s
  4.      Running unittests (target/debug/deps/limit_tracker-e599811fa246dbde)
  6. running 1 test
  7. test tests::it_sends_an_over_75_percent_warning_message ... FAILED
  9. failures:
  11. ---- tests::it_sends_an_over_75_percent_warning_message stdout ----
  12. thread 'main' panicked at 'already borrowed: BorrowMutError', src/lib.rs:60:53
  13. note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
  15. failures:
  16.     tests::it_sends_an_over_75_percent_warning_message
  18. test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
  20. error: test failed, to rerun pass '--lib'

注意代码 panic 和信息 already borrowed: BorrowMutError。这也就是 RefCell 如何在运行时处理违反借用规则的情况。

在运行时捕获借用错误而不是编译时意味着将会在开发过程的后期才会发现错误，甚至有可能发布到生产环境才发现；还会因为在运行时而不是编译时记录借用而导致少量的运行时性能惩罚。然而，使用 RefCell 使得在只允许不可变值的上下文中编写修改自身以记录消息的 mock 对象成为可能。虽然有取舍，但是我们可以选择使用 RefCell 来获得比常规引用所能提供的更多的功能。

结合 Rc 和 RefCell 来拥有多个可变数据所有者

RefCell 的一个常见用法是与 Rc 结合。回忆一下 Rc 允许对相同数据有多个所有者，不过只能提供数据的不可变访问。如果有一个储存了 RefCell 的 Rc 的话，就可以得到有多个所有者 并且 可以修改的值了！

例如，回忆示例 15-18 的 cons list 的例子中使用 Rc 使得多个列表共享另一个列表的所有权。因为 Rc 只存放不可变值，所以一旦创建了这些列表值后就不能修改。让我们加入 RefCell 来获得修改列表中值的能力。示例 15-24 展示了通过在 Cons 定义中使用 RefCell，我们就允许修改所有列表中的值了：

文件名: src/main.rs

  1. #[derive(Debug)]
  2. enum List {
  3.     Cons(Rc<RefCell<i32>>, Rc<List>),
  4.     Nil,
  5. }
  7. use crate::List::{Cons, Nil};
  8. use std::cell::RefCell;
  9. use std::rc::Rc;
  11. fn main() {
  12.     let value = Rc::new(RefCell::new(5));
  14.     let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));
  16.     let b = Cons(Rc::new(RefCell::new(3)), Rc::clone(&a));
  17.     let c = Cons(Rc::new(RefCell::new(4)), Rc::clone(&a));
  19.     *value.borrow_mut() += 10;
  21.     println!("a after = {:?}", a);
  22.     println!("b after = {:?}", b);
  23.     println!("c after = {:?}", c);
  24. }

示例 15-24：使用 Rc> 创建可以修改的 List

这里创建了一个 Rc> 实例并储存在变量 value 中以便之后直接访问。接着在 a 中用包含 value 的 Cons 成员创建了一个 List。需要克隆 value 以便 a 和 value 都能拥有其内部值 5 的所有权，而不是将所有权从 value 移动到 a 或者让 a 借用 value。

我们将列表 a 封装进了 Rc 这样当创建列表 b 和 c 时，他们都可以引用 a，正如示例 15-18 一样。

一旦创建了列表 a、b 和 c，我们将 value 的值加 10。为此对 value 调用了 borrow_mut，这里使用了第五章讨论的自动解引用功能（“-> 运算符到哪去了？” 部分）来解引用 Rc 以获取其内部的 RefCell 值。borrow_mut 方法返回 RefMut 智能指针，可以对其使用解引用运算符并修改其内部值。

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

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

这是非常巧妙的！通过使用 RefCell，我们可以拥有一个表面上不可变的 List，不过可以使用 RefCell 中提供内部可变性的方法来在需要时修改数据。RefCell 的运行时借用规则检查也确实保护我们免于出现数据竞争——有时为了数据结构的灵活性而付出一些性能是值得的。

标准库中也有其他提供内部可变性的类型，比如 Cell，它类似 RefCell 但有一点除外：它并非提供内部值的引用，而是把值拷贝进和拷贝出 Cell。还有 Mutex，其提供线程间安全的内部可变性，我们将在第 16 章中讨论其用法。请查看标准库来获取更多细节关于这些不同类型之间的区别。