[[419570]]

本文參考 rust book ch15 并添加了自己的理解，感興趣的可以先看看官方文檔

Rust 有兩種方式做到可變性

• 繼承可變性：比如一個 struct 聲明時指定 let mut, 那么后續(xù)可以修改這個結(jié)構(gòu)體的任一字段
• 內(nèi)部可變性：使用 Cell RefCell 包裝變量或字段，這樣即使外部的變量是只讀的，也可以修改

看似繼承可變性就夠了，那么為什么還需要所謂的 interior mutability 內(nèi)部可變性呢?讓我們分析兩個例子：

struct Cache { 
    x: i32, 
    y: i32, 
    sum: Option<i32>, 
} 
 
impl Cache { 
    fn sum(&mut self) -> i32 { 
        match self.sum { 
            None => {self.sum=Some(self.x + self.y); self.sum.unwrap()}, 
            Some(sum) => sum, 
        } 
    } 
} 
 
fn main() { 
    let i = Cache{x:10, y:11, sum: None}; 
    println!("sum is {}", i.sum()); 
} 

結(jié)構(gòu)體 Cache 有三個字段，x, y, sum, 其中 sum 模擬 lazy init 懶加載的模式，上面代碼是不能運行的，道理很簡單，當(dāng) let 初始化變量 i 時，就是不可變的。

17 |     let i = Cache{x:10, y:11, sum: None}; 
   |         - help: consider changing this to be mutable: `mut i` 
18 |     println!("sum is {}", i.sum()); 
   |                           ^ cannot borrow as mutable 

有兩種方式修復(fù)這個問題，let 聲明時指定 let mut i, 但具體大的項目時，外層的變量很可能是 immutable 不可變的。這時內(nèi)部可變性就派上用場了。

修復(fù)

use std::cell::Cell; 
 
struct Cache { 
    x: i32, 
    y: i32, 
    sum: Cell<Option<i32>>, 
} 
 
impl Cache { 
    fn sum(&self) -> i32 { 
        match self.sum.get() { 
            None => {self.sum.set(Some(self.x + self.y)); self.sum.get().unwrap()}, 
            Some(sum) => sum, 
        } 
    } 
} 
 
fn main() { 
    let i = Cache{x:10, y:11, sum: Cell::new(None)}; 
    println!("sum is {}", i.sum()); 
} 

這是修復(fù)之后的代碼，sum 類型是 Cell。

其實每一個都是有意義的，比如 Rc 代表共享所有權(quán)，但是因為 Rc 里的 T 要求是只讀的，不能修改，所以就要用 Cell 封一層，這樣就共享所有權(quán)，但還是可變的，Option 就是常見的要么有值 Some(T) 要么空值 None, 還是很好理解的。

如果不是寫 rust 代碼，只想閱讀源碼了解流程，沒必要深究這些 wrapper, 重點關(guān)注包裹的真實類型就可以。

官網(wǎng)舉的例子是 Mock Objects, 代碼比較長，但是原理一樣。

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

最后都是把結(jié)構(gòu)體字段，使用 RefCell 包裝一下。

Cell

use std::cell::Cell; 
 
fn main(){ 
    let a = Cell::new(1); 
    let b = &a; 
    a.set(1234); 
    println!("b is {}", b.get()); 
} 

這段代碼非常有代表性，如果變量 a 沒有用 Cell 包裹，那么在 b 只讀借用存在的時間，是不允許修改 a 的，由 rust 編譯器在 compile 編譯期保證：給定一個對像，在作用域內(nèi)(NLL)只允許存在 N 個不可變借用或者一個可變借用。

Cell 通過 get/set 來獲取和修改值，這個函數(shù)要求 value 必須實現(xiàn) Copy trait, 如果我們換成其它結(jié)構(gòu)體，編譯報錯。

error[E0599]: the method `get` exists for reference `&Cell<Test>`, but its trait bounds were not satisfied 
  --> src/main.rs:11:27 
   | 
3  | struct Test { 
   | ----------- doesn't satisfy `Test: Copy` 
... 
11 |     println!("b is {}", b.get().a); 
   |                           ^^^ 
   | 
   = note: the following trait bounds were not satisfied: 
           `Test: Copy` 

從上面可以看到 struct Test 默認沒有實現(xiàn) Copy, 所以不允許使用 get. 那有沒有辦法獲取底層 struct 呢?可以使用 get_mut 返回底層數(shù)據(jù)的引用，但這就要求整個變量是 let mut 的，所以與使用 Cell 的初衷不符，所以針對 Move 語義的場景，rust 提供了 RefCell。

RefCell

與 Cell 不一樣，我們使用 RefCell 一般通過 borrow 獲取不可變借用，或是 borrow_mut 獲取底層數(shù)據(jù)的可變借用。

use std::cell::{RefCell}; 
 
fn main() { 
    let cell = RefCell::new(1); 
 
    let mut cell_ref_1 = cell.borrow_mut(); // Mutably borrow the underlying data 
    *cell_ref_1 += 1; 
    println!("RefCell value: {:?}", cell_ref_1); 
 
    let mut cell_ref_2 = cell.borrow_mut(); // Mutably borrow the data again (cell_ref_1 is still in scope though...) 
    *cell_ref_2 += 1; 
    println!("RefCell value: {:?}", cell_ref_2); 
} 

代碼來自 badboi.dev, 編譯成功，但是運行失敗。

# cargo build 
    Finished dev [unoptimized + debuginfo] target(s) in 0.03s 
# 
# cargo run 
    Finished dev [unoptimized + debuginfo] target(s) in 0.03s 
     Running `target/debug/hello_cargo` 
RefCell value: 2 
thread 'main' panicked at 'already borrowed: BorrowMutError', src/main.rs:10:31 
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace 

cell_ref_1 調(diào)用 borrow_mut 獲取可變借用，還處于作用域時，cell_ref_2 也想獲取可變借用，此時運行時檢查報錯，直接 panic。

也就是說 RefCell 將借用 borrow rule 由編譯期 compile 移到了 runtime 運行時, 有一定的運行時開銷。

#[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); 
} 

這是官方例子，通過 Rc, RefCell 結(jié)合使用，做到共享所有權(quán)，同時又能修改 List 節(jié)點值。

小結(jié) 

內(nèi)部可變性提供了極大的靈活性，但是考濾到運行時開銷，還是不能濫用，性能問題不大，重點是缺失了編譯期的靜態(tài)檢查，會掩蓋很多錯誤。