Module core::cell

1.0.0 · source ·
Expand description

可共享的可变容器。

Rust 内存安全基于以下规则:给定一个对象 T,它只能具有以下之一:

  • 对对象具有多个不可变引用 (&T) (也称为别名)。
  • 对对象有一个可变引用 (&mut T) (也称为可变性)。

这由 Rust 编译器强制执行。但是,在某些情况下,此规则不够灵活。有时需要对一个对象进行多次引用,然后对其进行可变的。

存在共享的可变容器以允许以受控的方式进行可变性,即使在出现混叠的情况下也是如此。 Cell<T>RefCell<T>OnceCell<T> 允许以单线程方式实现这一点,但它们不实现 Sync。 (如果您需要在多个线程之间进行别名和可变的,Mutex<T>RwLock<T>OnceLock<T>atomic 类型是执行此操作的正确数据结构)。

Cell<T>RefCell<T>OnceCell<T> 类型的值可以通过共享引用 (即常见的 &T 类型) 进行可变,而大多数 Rust 类型只能通过唯一的 (&mut T) 引用进行可变。 我们说这些 cell 类型提供 内部可变性 (通过 &T 可变),与表现出 继承可变性 (仅通过 &mut T 可变) 的典型 Rust 类型形成对比。

Cell 类型分为三种类型: Cell<T>RefCell<T>OnceCell<T>。每个都提供了一种不同的方式来提供安全的内部可变性。

Cell<T>

Cell<T> 通过将值移入和移出 cell 来实现内部可变性。 也就是说,永远无法获取到内部值的 &mut T,如果不将其替换为其他内容,则无法直接获取值本身。 这两条规则都确保永远不会有一个以上的引用指向内部值。 该类型提供了以下方法:

  • 对于实现 Copy 的类型,get 方法通过复制它来检索当前内部值。
  • 对于实现 Default 的类型,take 方法将当前内部值替换为 Default::default(),然后返回替换后的值。
  • 所有类型都有:
    • replace: 替换当前内部值并返回替换后的值。
    • into_inner: 此方法使用 Cell<T> 并返回内部值。
    • set: 该方法替换内部值,丢弃替换后的值。

Cell<T> 通常用于更简单的类型,在这些类型中复制或移动值不会占用太多资源 (例如数字),并且在可能的情况下通常应优先于其他 cell 类型。 对于较大的非复制类型,RefCell 提供了一些优势。

RefCell<T>

RefCell<T> 使用 Rust 的生命周期来实现 “dynamic borrowing”,这是一个可以临时、独占、可更改访问内部值的过程。 RefCell<T>s 的引用在运行时被跟踪,这与 Rust 的原生引用类型不同,后者在编译时完全静态地被跟踪。

可以使用 borrow 获取对 RefCell 的内部值 (&T) 的不可更改引用,使用 borrow_mut 可以获取不可更改引用 (&mut T)。 当调用这些函数时,它们首先验证是否满足 Rust 的借用规则: 允许任意数量的不可改变借用或允许单个不可改变借用,但绝不能同时使用。 如果尝试违反这些规则的借用,线程将崩溃。

RefCell<T> 对应的 Sync 版本为 RwLock<T>

OnceCell<T>

OnceCell<T> 在某种程度上是 CellRefCell 的混合体,适用于通常只需要设置一次的值。 这意味着无需移动或复制内部值 (与 Cell 不同) 也无需运行时检查 (与 RefCell 不同) 即可获得引用 &T。 然而,它的值一旦设置也不能更新,除非您有一个可变引用到 OnceCell

OnceCell 提供了以下方法:

  • get: 获取对内部值的引用
  • set: 如果未设置则设置内部值 (返回 Result)
  • get_or_init: 返回内部值,如果需要则初始化它
  • get_mut: 提供对内部值的可变引用,仅当您对 cell 本身具有可变引用时才可用。

OnceCell<T> 对应的 Sync 版本为 OnceLock<T>

何时选择内部可变性

更常见的继承的可变性 (其中必须具有对值的唯一访问权) 是使 Rust 能够强烈考虑指针别名的关键语言元素之一,从而可以静态地防止崩溃错误。 因此,首选继承的可变性,而内部可变性则是不得已而为之。 由于 cell 类型能够在不允许的情况下实现可变,所以有时内部可变性可能是合适的,或者甚至必须使用,例如

  • 在不可变的内部引入可变性
  • 逻辑上不可变的方法的实现细节。
  • Clone 的变异实现。

在不可变的内部引入可变性

许多共享的智能指针类型,包括 Rc<T>Arc<T>,都提供了可以在多方之间克隆和共享的容器。 由于所包含的值可能具有多重别名,因此只能使用 &,而不能使用 &mut 来借用它们。 如果没有 cell,根本不可能改变这些智能指针内的数据。

然后,在共享指针类型中放置一个 RefCell<T> 来重新引入可变性是非常常见的:

use std::cell::{RefCell, RefMut};
use std::collections::HashMap;
use std::rc::Rc;

fn main() {
    let shared_map: Rc<RefCell<_>> = Rc::new(RefCell::new(HashMap::new()));
    // 创建一个新块以限制动态借用的作用域
    {
        let mut map: RefMut<'_, _> = shared_map.borrow_mut();
        map.insert("africa", 92388);
        map.insert("kyoto", 11837);
        map.insert("piccadilly", 11826);
        map.insert("marbles", 38);
    }

    // 请注意,如果我们没有让缓存的上一次借用离开作用域,那么后续的借用将导致动态线程 panic。
    //
    // 这是使用 `RefCell` 的主要危险。
    let total: i32 = shared_map.borrow().values().sum();
    println!("{total}");
}
Run

请注意,这个例子使用了 Rc<T> 而不是 Arc<T>RefCell<T>s 适用于单线程场景。如果在多线程情况下需要共享可变性,可以考虑使用 RwLock<T>Mutex<T>

逻辑上的不可变方法的实现细节

有时,可能希望不要在 API 中公开幕后发生了变异。 这可能是因为逻辑上该操作是不可变的,但是例如,缓存会强制实现执行变异; 或者是因为您必须使用突变来实现一个最初定义为接受 &self 的 trait 方法。

use std::cell::RefCell;

struct Graph {
    edges: Vec<(i32, i32)>,
    span_tree_cache: RefCell<Option<Vec<(i32, i32)>>>
}

impl Graph {
    fn minimum_spanning_tree(&self) -> Vec<(i32, i32)> {
        self.span_tree_cache.borrow_mut()
            .get_or_insert_with(|| self.calc_span_tree())
            .clone()
    }

    fn calc_span_tree(&self) -> Vec<(i32, i32)> {
        // 昂贵的计算在这里
        vec![]
    }
}
Run

Clone 的变异实现

这只是一种特殊情况 - 但很常见 - 以前的情况:隐藏看起来不可变的操作的可变性。 clone 方法不会更改源值,并声明采用 &self,而不是 &mut self。 因此,在 clone 方法中发生的任何变异的都必须使用 cell 类型。 例如,Rc<T>Cell<T> 中维护它的引用计数。

use std::cell::Cell;
use std::ptr::NonNull;
use std::process::abort;
use std::marker::PhantomData;

struct Rc<T: ?Sized> {
    ptr: NonNull<RcBox<T>>,
    phantom: PhantomData<RcBox<T>>,
}

struct RcBox<T: ?Sized> {
    strong: Cell<usize>,
    refcount: Cell<usize>,
    value: T,
}

impl<T: ?Sized> Clone for Rc<T> {
    fn clone(&self) -> Rc<T> {
        self.inc_strong();
        Rc {
            ptr: self.ptr,
            phantom: PhantomData,
        }
    }
}

trait RcBoxPtr<T: ?Sized> {

    fn inner(&self) -> &RcBox<T>;

    fn strong(&self) -> usize {
        self.inner().strong.get()
    }

    fn inc_strong(&self) {
        self.inner()
            .strong
            .set(self.strong()
                     .checked_add(1)
                     .unwrap_or_else(|| abort() ));
    }
}

impl<T: ?Sized> RcBoxPtr<T> for Rc<T> {
   fn inner(&self) -> &RcBox<T> {
       unsafe {
           self.ptr.as_ref()
       }
   }
}
Run

Structs