Rc 和 Weak 源码详解
一个值需要被多个所有者拥有
- rust中所有权机制在图这种数据结构中，一个节点可能被多个其它节点所指向。那么如何表示图这种数据结构？
- 在多线程中，多个线程可能会持有同一个数据？如何解决这个问题。
Rc
rust 通过使用引用计数智能指针 Rc 和 Arc 来解决上面的问题。当我们对一个被 Rc 所标识的数据进行 clone() 的时候，并不会复制其内部数据，只是增加引用计数，而当一个 Rc 被 drop 的时候，只会减少其引用计数，直到引用计数为0，此时才会真正清除对应的内存。
但是使用引用计数方案有一个问题，那就是如何解决循环引用问题？如果不了解引用计数方式管理内存的，可以看这篇文章。rust 为了解决这个问题，提供了弱引用(Weak)。它不拥有数据的所有权，只产生弱引用计数。
我们来看一下 Rc 这个结构
rust
#[cfg_attr(not(test), rustc_diagnostic_item = "Rc")]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_insignificant_dtor]
pub struct Rc<T: ?Sized> {
ptr: NonNull<RcBox<T>>,
phantom: PhantomData<RcBox<T>>,
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !Send for Rc<T> {}
// Note that this negative impl isn't strictly necessary for correctness,
// as `Rc` transitively contains a `Cell`, which is itself `!Sync`.
// However, given how important `Rc`'s `!Sync`-ness is,
// having an explicit negative impl is nice for documentation purposes
// and results in nicer error messages.
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !Sync for Rc<T> {}首先，Rc 是一个结构体，可以看到它不满足 Send 和 Sync 这两个 trait，这意味着 Rc 是不能跨线程的，它只适用于单线程下的引用计数。这是 rust 专门为单线程场景设计的高性能引用计数器；而多线程下需要 Arc (atomic reference counting)来实现多线程的引用计数。
另外一点就是 Rc 接受的泛型参数可以是大小未知（unsized）类型。Rc 结构体中有两个字段 ptr 和 phantom 。ptr 的类型是NonNull<RcBox<T>>
rust
pub struct NonNull<T: ?Sized> {
pointer: *const T,
}也就是说 ptr 实际上是一个指向 RcBox<T> 的非空指针。OK，我们接着来看一下 RcBox 类型
rust
struct RcBox<T: ?Sized> {
strong: Cell<usize>,
weak: Cell<usize>,
value: T,
}下面，让我来详细解释这个结构体的各个字段：
-
strong: Cell<usize>：这个字段是一个 Cell 类型的包装，用于存储强引用计数（strong reference count）。Cell 是 rust标准库提供的一种允许在不可变情况下修改其内部值的类型。强引用计数用于跟踪有多少个 Rc 实例仍然拥有对数据的引用。每当创建一个新的 Rc 引用时，强引用计数会递增；当 Rc 引用离开作用域或被丢弃时，强引用计数递减。 -
weak: Cell<usize>：这个字段是一个 Cell 类型的包装，用于存储弱引用计数（weak reference count）。弱引用计数用于跟踪有多少个 Weak 引用（Rc 的弱引用）仍然存在，但它不会阻止数据的销毁。与强引用不同，当只有弱引用剩余时，数据可以被销毁。每当创建一个新的 Weak 引用时，弱引用计数会递增；当Weak 引用离开作用域或被丢弃时，弱引用计数递减。 -
value: T：这是 Rc 包装的实际值的字段。Rc 用于共享这个值，因此它包含在 RcBox 中。
既然强引用，弱引用以及值都包含在 RcBox 中了，那么 phantom: PhantomData<RcBox<T>> 的作用是什么？
PhantomData 是一个泛型类型，通常用于标记类型参数在运行时不实际占用内存。在这里，它用于确保 RcBox<T> 存在，尽管它在运行时不占用内存。这是为了帮助Rust编译器进行正确的类型检查和生命周期分析。
rust
pub struct PhantomData<T: ?Sized>;正如我们所见，PhantomData 是一个单元结构体，它的大小是零字节，不占用内存空间。
我们进一步来看一下 Rc 的构造方法，看看它到底是如何做到让一个值可以有多个所有者？按照之前的一个值只有一个所有者的模型，当所有者生命周期结束的时候，值就会被回收；而 Rc 是在强引用计数到 0 的时候，释放内存。
rust
pub fn new(value: T) -> Rc<T> {
// There is an implicit weak pointer owned by all the strong
// pointers, which ensures that the weak destructor never frees
// the allocation while the strong destructor is running, even
// if the weak pointer is stored inside the strong one.
unsafe {
Self::from_inner(
Box::leak(Box::new(RcBox { strong: Cell::new(1), weak: Cell::new(1), value }))
.into(),
)
}
}首先，我们注意到 new 的实现代码是 unsafe 的，这是因为 Box::leak 方法将 Box 中的数据泄漏（leak）出来，而这个操作将绕过 Rust 的所有权和生命周期检查，这样 RcBox 结构体数据将被泄漏到堆上，使其在函数结束后继续存在，而不是按正常方式被释放，通过这种手段，让 RcBox 拥有了足够长的生命周期，以便在多个 Rc 实例之间正确地共享数据。
这段代码的注释中还告诉了我们：所有强引用指针（Rc 实例）之间都存在一个隐式的弱引用指针。这个隐式的弱引用用于确保在强引用的析构函数运行期间，弱引用不会释放数据，即使在强引用指针中存储了一个弱引用。后面当我们介绍 Weak 析构函数的时候，会看到它需要先读取 RcBox 中的数据。这样就防止弱引用析构执行的时候会访问到悬垂指针。
接着，我们来看一下析构函数的代码。
rust
fn drop(&mut self) {
unsafe {
self.inner().dec_strong(); // 强引用计数减 1
if self.inner().strong() == 0 {
// destroy the contained object
ptr::drop_in_place(Self::get_mut_unchecked(self));
// remove the implicit "strong weak" pointer now that we've
// destroyed the contents.
self.inner().dec_weak(); // 弱引用计数减 1
if self.inner().weak() == 0 {
Global.deallocate(self.ptr.cast(), Layout::for_value(self.ptr.as_ref()));
}
}
}
}- 如果强引用计数为零，表示没有任何强引用指向数据了，这意味着数据可以安全地被销毁。
- 如果弱引用计数降至零，表示没有任何弱引用指向数据，将弱引用相关的资源清理掉。
既然 RcBox 中也存储了弱引用计数，那么 Rc 肯定提供了从一个 Rc 获取到 弱引用的方法。实际上就是 downgrade 方法
rust
pub fn downgrade(this: &Self) -> Weak<T> {
this.inner().inc_weak();
// Make sure we do not create a dangling Weak
debug_assert!(!is_dangling(this.ptr.as_ptr()));
Weak { ptr: this.ptr }
}这个函数非常简单，让弱引用计数加1，然后保证不是悬垂指针之后，用这个指针作为参数构造了一个 Weak 返回。这样就实现了从 Rc 中获取 Weak。
Weak
我们顺便来看一下弱引用，Weak 用于创建弱引用，通常与 Rc 智能指针一起使用。
rust
pub struct Weak<T: ?Sized> {
// This is a `NonNull` to allow optimizing the size of this type in enums,
// but it is not necessarily a valid pointer.
// `Weak::new` sets this to `usize::MAX` so that it doesn't need
// to allocate space on the heap. That's not a value a real pointer
// will ever have because RcBox has alignment at least 2.
// This is only possible when `T: Sized`; unsized `T` never dangle.
ptr: NonNull<RcBox<T>>,
}Weak 也存储了一个指向 RcBox 的指针。看起来这是比 Rc 少了一个标记字段，实际上它们的构造函数完全不同。
rust
pub const fn new() -> Weak<T> {
Weak { ptr: unsafe { NonNull::new_unchecked(ptr::invalid_mut::<RcBox<T>>(usize::MAX)) } }
}ptr::invalid_mut 函数来创建一个无效的指针，其值被设置为 usize::MAX。这个无效指针用于表示一个 Weak 弱引用指针，它不引用任何真实的数据，但是用于表示一个空的 Weak 实例，然后将其包装在 NonNull 中，并返回作为 Weak 实例的一部分。这个无效的 Weak 实例通常用于初始化，之后可以使用 upgrade 方法来尝试获取一个真实的强引用。
实际上，在 Weak 结构体的注释中已经解释了 new 方法为什么会是这样。设置为 usize::MAX 的目的是为了避免在创建 Weak 时需要分配堆内存。由于 Weak 通常用于检查数据的存在性而不需要实际引用数据。
我们再来看一下析构函数，
rust
fn drop(&mut self) {
let inner = if let Some(inner) = self.inner() { inner } else { return };
inner.dec_weak(); // 弱引用计数减1
// the weak count starts at 1, and will only go to zero if all
// the strong pointers have disappeared.
if inner.weak() == 0 {
unsafe {
Global.deallocate(self.ptr.cast(), Layout::for_value_raw(self.ptr.as_ptr()));
}
}
}let inner = if let Some(inner) = self.inner() { inner } else { return };：这一行代码的目的是获取 Weak 引用内部的 RcBox 数据结构，以便后续操作。self.inner() 方法用于获取内部数据，如果存在则返回 Some(inner)，否则返回 None。如果不存在内部数据，说明这个 Weak 已经被销毁，所以函数提前返回（return）。
如果弱引用计数降至零，说明没有任何弱引用指向数据，这意味着数据可以被释放。此时使用 Global.deallocate 来释放和 Weak 相关的内存。
前面说过可以通过 Rc 获取到一个弱引用，那么同样，当我们需要通过 Weak 来获取数据的时候，就会产生一个 Rc。这个时候就需要使用 Weak 提供的 upgrade 方法。
rust
pub fn upgrade(&self) -> Option<Rc<T>> {
let inner = self.inner()?;
if inner.strong() == 0 {
None
} else {
unsafe {
inner.inc_strong();
Some(Rc::from_inner(self.ptr))
}
}
}首先，尝试获取 RcBox 中的数据，如果是 None，则直接返回，否则获取到 RcBox 中的数据，进行强引用计数判断，如果强引用计数为 0，那么意味着数据被释放，返回 None，否则将强引用计数加 1，然后返回一个 Rc 实例。