“内部可变性”的概念讲起来很有迷惑性，理论知识可能很容易将新手绕晕。先来通俗说一下它的用途。其实这东西的产生，是因为 Rust 的规矩太多，有着严格的内存访问限制。内部可变性是一种变通手段，将“破例”的行为仍然约束在 Rust 可控的范围。就是说，你想破例也要按我的规则来破例。

我们都知道，Rust 的内存安全基于以下规则：给定对象 T，只能有以下情况之一：
1.对该对象有多个不可变引用（&T）（也称为别名）。
2.对该对象有一个可变引用（&mut T）（也称为可变性）。

这一规则由 Rust 编译器强制执行。然而，有些情况下该规则并不够灵活。有时会需要多个引用指向一个对象，并能同时对其进行修改。而 Rust 提供的 可共享的可变容器（Shareable mutable containers） 则允许以一种受控的方式实现可变性，即使已经存在别名。

这些容器包括：Cell<T>、RefCell<T> 等，它们允许以单线程方式进行这样的操作；而多个线程之间进行不可变引用引用并修改时，则可以使用 Mutex<T> 等。事实上 Mutex 不过是一种实现“多个引用指向一个对象，并能同时对其进行修改”这一目的的方法而已。它为内部数据提供独占（mut）访问权限，尽管许多线程可能对 Mutex 本身具有共享（非 mut）访问权限。

总结一下，内部可变性是一种允许在拥有不可变引用的同时修改数据的概念。这种能力是通过特定类型的容器实现的。这些容器允许在不违反借用规则的情况下，在拥有不可变引用的同时对数据进行修改。

如果还不懂，咱们来详细说一下。

首先，既然有内部可变性，就有对应的外部可变性。 外部可变性一言以蔽之就是：变量的可变性直接继承自包含该变量的容器。其实从其英文名 inherited mutability 我们可以感知到这点。

比方说有容器（此处为结构体）Book ：

struct Book {
    name: String,
}

如果想为其增加一个方法，用来更改其 name：

impl Book {
    fn change_name(&self, new_name: String) {
        self.name = new_name;
    }
}

然后你会发现编译错误：

cannot assign to `self.name`, which is behind a `&` reference

这是因为该类型需要从父级传递 &mut 访问权限到子级，或者说是从容器到内容。只有当你拥有对容器 self 的 &mut 引用时，才会预期能够调用内容 self.name 并为其赋值。

impl Book {
    fn change_name(&mut self, new_name: String) {
        self.name = new_name;
    }
}

同样的，下面的代码也将无法编译：

let a = Book {
    name: String::from("老子"),
};
a.change_name(String::from("庄子"));

需要将 a 改为 mut a 方可编译。这是默认行为，因为如果你没有对父级的独占访问权限，Rust 通常无法确保你对子级有独占访问权限。内部可变性不同于 Rust 默认的“持有共享引用不能改变”或“持有可变引用不能还有共享引用”的非此即彼的编译期约束。它更应该叫共享可变性——持有共享引用还可以改变数据。

现在来看 Rust 为“破例”而设立的规则。其实就是用特定的容器来包裹你想要“破例”的内容，以便编译器能识别到它们。这类容器典型的有 Cell<T> 与 RefCell<T>。而关于 Cell<T> 与 RefCell<T> 的区别，其实你只要记清：Cell<T> 适用于实现 Copy trait 的类型，而 RefCell<T> 适用于非 Copy 类型即可。

我们来为 Book 增加点内容：

struct Book {
    name: String,
    price: Cell<i32>,
    author: RefCell<String>,
}

price 为 i32 类型的，实现了 Copy ，所以我们用 Cell 包裹，相应的，String 类型的 author 则用了 RefCell 包裹。

再增加两个方法：

fn change_price(&self, new_price: i32) {
    self.price.set(new_price);
}
fn change_author(&self, new_author: String) {
    let mut a = self.author.borrow_mut();
    *a = new_author;
}

我们注意到，此时不再需要 &mut self。调用的时候：

let a = Book {
    name: String::from("老子"),
    price: Cell::new(25),
    author: RefCell::new(String::from("老子")),
};

a.change_author(String::from("李耳"));
let b = &a;
b.change_price(30);
a.change_price(21);

而如果你尝试以下代码，理所当然会出现编译错误：

a.change_name(String::from("庄子"));

这样一来，我们的破例行为又符合 Rust 的规则了。而明白了这一点，再去从 API 文档中详细学习 Cell<T> 、RefCell<T> 或是其它此类可共享的可变容器时，你便会有的放矢了。

最后我们把 author 打印出来看一下：

println!("{:?}", a.author.borrow());  // "李耳"

没有问题。但如果我们尝试把 change_author 方法中的代码 copy 到 main 中来：

let a = Book { ... };
...

let mut d = a.author.borrow_mut();
*d = String::from("老聃");

println!("{:?}", a.author.borrow());

编译没问题，运行时却会报错：

然后我明确地进行 drop(d) 操作后，就又正常了：

let mut d = a.author.borrow_mut();
*d = String::from("老聃");
drop(d);

println!("{:?}", a.author.borrow());

想想看为什么？