20240807
循环引用与自引用
实现一个链表是学习各大编程语言的常用技巧，但是在 Rust 中实现链表意味着····Hell，是的，你没看错，Welcome to hell。
链表在 Rust 中之所以这么难，完全是因为循环引用和自引用的问题引起的，这两个问题可以说综合了 Rust 的很多难点，难出了新高度，因此本书专门开辟一章，分为上下两篇，试图彻底解决这两个老大难。
本章难度较高，但是非常值得深入阅读，它会让你对 Rust 的理解上升到一个新的境界。
Weak 与循环引用
Rust 的安全性是众所周知的，但是不代表它不会内存泄漏。一个典型的例子就是同时使用 Rc<T> 和 RefCell<T> 创建循环引用，最终这些引用的计数都无法被归零，因此 Rc<T> 拥有的值也不会被释放清理。
何为循环引用
关于内存泄漏，如果你没有充足的 Rust 经验，可能都无法造出一份代码来再现它：
use crate::List::{Cons, Nil};
use std::cell::RefCell;
use std::rc::Rc;
#[derive(Debug)]
enum List {
Cons(i32, RefCell<Rc<List>>),
Nil,
}
impl List {
fn tail(&self) -> Option<&RefCell<Rc<List>>> {
match self {
Cons(_, item) => Some(item),
Nil => None,
}
}
}
fn main() {}
这里我们创建一个有些复杂的枚举类型 List，这个类型很有意思，它的每个值都指向了另一个 List，此外，得益于 Rc 的使用还允许多个值指向一个 List：
如上图所示，每个矩形框节点都是一个 List 类型，它们或者是拥有值且指向另一个 List 的Cons，或者是一个没有值的终结点 Nil。同时，由于 RefCell 的使用，每个 List 所指向的 List 还能够被修改。
下面来使用一下这个复杂的 List 枚举：
fn main() {
let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));
// 内容 Cons(5, RefCell::new(Rc::new(Nil)))记作 A，此时let a = Rc::new(A),即a是A的引用，则此时a指向内容A，对A的计数加1
println!("a的初始化rc计数 = {}", Rc::strong_count(&a));//打印 指向A的计数是多少
println!("a指向的节点 = {:?}", a.tail());
// 创建`b`到`a`的引用
let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a))));
//内容 Cons(10, RefCell::new(Rc::clone(&a)))记作 B，此时let b = Rc::new(B)，即b是B的引用，则此时b指向内容B，对B的记数加1
//又因为B中涉及一条Rc::clone(&a)，即产生了一条对引用a的复制，即对内容A的引用，此时指向A的计数加1
println!("在b创建后，a的rc计数 = {}", Rc::strong_count(&a));//打印 指向A的计数是多少
println!("b的初始化rc计数 = {}", Rc::strong_count(&b));//打印 指向B的计数是多少
println!("b指向的节点 = {:?}", b.tail());
// 利用RefCell的可变性，创建了`a`到`b`的引用
if let Some(link) = a.tail() {
*link.borrow_mut() = Rc::clone(&b);
//这里出现了Rc::clone(&b)，即产生了一条对引用b的复制，即对内容B的引用，此时指向B的计数加一
}
println!("在更改a后，b的rc计数 = {}", Rc::strong_count(&b));
println!("在更改a后，a的rc计数 = {}", Rc::strong_count(&a));
// 下面一行println!将导致循环引用
// 我们可怜的8MB大小的main线程栈空间将被它冲垮，最终造成栈溢出
// println!("a next item = {:?}", a.tail());
}
这个类型定义看着复杂，使用起来更复杂！不过排除这些因素，我们可以清晰看出：
- 在创建了 a 后，紧接着就使用 a 创建了 b，因此 b 引用了 a
- 然后我们又利用 Rc 克隆了 b，然后通过 RefCell 的可变性，让 a 引用了 b
至此我们成功创建了循环引用a-> b -> a -> b ····
先来观察下引用计数：
a的初始化rc计数 = 1
a指向的节点 = Some(RefCell { value: Nil })
在b创建后，a的rc计数 = 2
b的初始化rc计数 = 1
b指向的节点 = Some(RefCell { value: Cons(5, RefCell { value: Nil }) })
在更改a后，b的rc计数 = 2
在更改a后，a的rc计数 = 2
在 main 函数结束前，a 和 b 的引用计数均是 2，随后 b 触发 Drop，此时引用计数会变为 1，并不会归 0，因此 b 所指向内存不会被释放，同理可得 a 指向的内存也不会被释放，最终发生了内存泄漏。
- 内存泄漏是指程序在运行过程中，由于某些原因导致无法再访问的内存没有被正确释放，从而使得这些内存一直被占用，最终可能导致系统资源耗尽。
下面一张图很好的展示了这种引用循环关系：
现在我们还需要轻轻的推一下，让塔米诺骨牌轰然倒塌。反注释最后一行代码，试着运行下：
RefCell { value: Cons(5, RefCell { value: Cons(10, RefCell { value: Cons(5, RefCell { value: Cons(10, RefCell { value: Cons(5, RefCell { value: Cons(10, RefCell {
...无穷无尽
thread 'main' has overflowed its stack
fatal runtime error: stack overflow
通过 a.tail 的调用，Rust 试图打印出 a -> b -> a ··· 的所有内容，但是在不懈的努力后，main 线程终于不堪重负，发生了栈溢出。
以上的代码可能并不会造成什么大的问题，但是在一个更加复杂的程序中，类似的问题可能会造成你的程序不断地分配内存、泄漏内存，最终程序会不幸OOM(Out Of Memory)，当然这其中的 CPU 损耗也不可小觑。
总之，创建循环引用并不简单，但是也并不是完全遇不到，当你使用 RefCell<Rc<T>> 或者类似的类型嵌套组合（具备内部可变性和引用计数）时，就要打起万分精神，前面可能是深渊！
那么问题来了？ 如果我们确实需要实现上面的功能，该怎么办？答案是使用 Weak。
Weak
Weak 非常类似于 Rc，但是与 Rc 持有所有权不同，Weak 不持有所有权，它仅仅保存一份指向数据的弱引用：如果你想要访问数据，需要通过 Weak 指针的 upgrade 方法实现，该方法返回一个类型为 Option<Rc<T>> 的值。
看到这个返回，相信大家就懂了：何为弱引用？就是不保证引用关系依然存在，如果不存在，就返回一个 None！
因为 Weak 引用不计入所有权，因此它无法阻止所引用的内存值被释放掉，而且 Weak 本身不对值的存在性做任何担保，引用的值还存在就返回 Some，不存在就返回 None。
Weak 与 Rc 对比
我们来将 Weak 与 Rc 进行以下简单对比：
| Weak | Rc |
|---|---|
| 不计数 | 引用计数 |
| 不拥有所有权 | 拥有值的所有权 |
| 不阻止值被释放(drop) | 所有权计数归零，才能 drop |
| 引用的值存在返回Some，不存在返回None | 引用的值必定存在 |
| 通过 upgrade 取到 Option<Rc<T>>，然后再取值 | 通过 Deref 自动解引用，取值无需任何操作 |
通过这个对比，可以非常清晰的看出 Weak 为何这么弱，而这种弱恰恰非常适合我们实现以下的场景：
- 可访问，但没有所有权，不增加引用计数，因此不会影响被引用值的释放回收
- 可由 Rc<T> 调用 downgrade 方法转换成 Weak<T>
- Weak<T> 可使用 upgrade 方法转换成 Option<Rc<T>>，如果资源已经被释放，则 Option 的值是 None
- 常用于解决循环引用的问题
一个简单的例子：
use std::rc::Rc;
fn main() {
// 创建Rc，持有一个值5
let five = Rc::new(5);
// 通过Rc，创建一个Weak指针
let weak_five = Rc::downgrade(&five);
// Weak引用的资源依然存在，取到值5
let strong_five: Option<Rc<_>> = weak_five.upgrade();
assert_eq!(*strong_five.unwrap(), 5);
// 手动释放资源`five`
drop(five);
// Weak引用的资源已不存在，因此返回None
let strong_five: Option<Rc<_>> = weak_five.upgrade();
assert_eq!(strong_five, None);
}
使用 Weak 解决循环引用
需要承认的是，使用 Weak 让 Rust 本来就堪忧的代码可读性又下降了不少，但是。。。真香，因为可以解决循环引用了。
现在用两个例子来模拟下真实场景下可能会遇到的循环引用。
工具间的故事
工具间里，每个工具都有其主人，且多个工具可以拥有一个主人；同时一个主人也可以拥有多个工具，在这种场景下，就很容易形成循环引用，好在我们有 Weak：
use std::rc::Rc;
use std::rc::Weak;
use std::cell::RefCell;
// 主人
struct Owner {
name: String,
gadgets: RefCell<Vec<Weak<Gadget>>>,
}
// 工具
struct Gadget {
id: i32,
owner: Rc<Owner>,
}
fn main() {
// 创建一个 Owner
// 需要注意，该 Owner 也拥有多个 `gadgets`
let gadget_owner : Rc<Owner> = Rc::new(
Owner {
name: "Gadget Man".to_string(),
gadgets: RefCell::new(Vec::new()),
}
);
// 创建工具，同时与主人进行关联：创建两个 gadget，他们分别持有 gadget_owner 的一个引用。
let gadget1 = Rc::new(Gadget{id: 1, owner: gadget_owner.clone()});
let gadget2 = Rc::new(Gadget{id: 2, owner: gadget_owner.clone()});
// 为主人更新它所拥有的工具
// 因为之前使用了 `Rc`，现在必须要使用 `Weak`，否则就会循环引用
gadget_owner.gadgets.borrow_mut().push(Rc::downgrade(&gadget1));
gadget_owner.gadgets.borrow_mut().push(Rc::downgrade(&gadget2));
// 遍历 gadget_owner 的 gadgets 字段
for gadget_opt in gadget_owner.gadgets.borrow().iter() {
// gadget_opt 是一个 Weak<Gadget> 。 因为 weak 指针不能保证他所引用的对象
// 仍然存在。所以我们需要显式的调用 upgrade() 来通过其返回值(Option<_>)来判
// 断其所指向的对象是否存在。
// 当然，Option 为 None 的时候这个引用原对象就不存在了。
let gadget = gadget_opt.upgrade().unwrap();
println!("Gadget {} owned by {}", gadget.id, gadget.owner.name);
}
// 在 main 函数的最后，gadget_owner，gadget1 和 gadget2 都被销毁。
// 首先 gadget2 和 gadget1 被销毁。因为gadget_owner对gadget1和2是weak引用，所以不影响二者的drop
// 然后因为 gadget2 和 gadget1 被销毁，二者对gadget_owner 的引用数量为 0，所以这个对象可以被销毁了。
// 循环引用问题也就避免了
}
tree 数据结构：
use std::cell::RefCell;
use std::rc::{Rc, Weak};
#[derive(Debug)]
struct Node {
value: i32,
parent: RefCell<Weak<Node>>,
children: RefCell<Vec<Rc<Node>>>,
}
fn main() {
let leaf = Rc::new(Node {
value: 3,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![]),
});
println!(
"leaf strong = {}, weak = {}",
Rc::strong_count(&leaf),
Rc::weak_count(&leaf),
);
{
let branch = Rc::new(Node {
value: 5,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![Rc::clone(&leaf)]),
});
*leaf.parent.borrow_mut() = Rc::downgrade(&branch);
println!(
"branch strong = {}, weak = {}",
Rc::strong_count(&branch),
Rc::weak_count(&branch),
);
println!(
"leaf strong = {}, weak = {}",
Rc::strong_count(&leaf),
Rc::weak_count(&leaf),
);
}
println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
println!(
"leaf strong = {}, weak = {}",
Rc::strong_count(&leaf),
Rc::weak_count(&leaf),
);
}
这段Rust代码演示了如何使用 Rc 和 Weak 来创建一个具有父节点和子节点的树形结构，同时避免循环引用导致的内存泄漏问题。下面是代码的逐行解释：
-
1.导入必要的模块：std::cell::RefCell 用于内部可变性，std::rc::{Rc, Weak} 用于引用计数智能指针。
-
2.定义一个名为 Node 的结构体，包含：
value：i32 类型的值。
parent：RefCell<Weak<Node>> 类型，表示父节点的弱引用。
children：RefCell<Vec<Rc<Node>>> 类型，表示子节点的列表，使用 Rc 进行强引用。 -
3.在 main 函数中创建一个叶节点 leaf，初始化其 value，parent 为 Weak::new()（空弱引用），children 为空向量。
-
4.打印 leaf 的强引用计数和弱引用计数。
-
5.创建一个分支节点 branch，初始化其 value，parent 为 Weak::new()，children 包含对 leaf 的强引用。
-
6.将 leaf 的 parent 指向 branch，使用 Rc::downgrade(&branch) 创建 branch 的弱引用。
-
7.打印 branch 的强引用计数和弱引用计数。
-
8.打印更新 leaf 父节点后的强引用计数和弱引用计数。
-
9.退出 branch 的作用域，branch 的 Rc 被销毁，但 leaf 仍然存在，因为它只持有 branch 的弱引用。
-
10.打印 leaf 的父节点，使用 Weak 的 upgrade 方法尝试将其转换回 Rc。由于 branch 已经超出作用域并被销毁，upgrade 将返回 None。
-
11.打印 leaf 的最终强引用计数和弱引用计数，强引用计数为1，因为只有 leaf 存在，弱引用计数也为1，因为 leaf 的 parent 是一个弱引用。
这段代码展示了如何使用 Weak 指针来避免循环引用，Weak 指针不增加 Rc 的强引用计数，从而允许 Rc 在不再需要时被正确地销毁。这是管理内存和避免内存泄漏的一种有效方式。
unsafe 解决循环引用
除了使用 Rust 标准库提供的这些类型，你还可以使用 unsafe 里的裸指针来解决这些棘手的问题，但是由于我们还没有讲解 unsafe，因此这里就不进行展开，只附上源码链接，挺长的，需要耐心 o_o
虽然 unsafe 不安全，但是在各种库的代码中依然很常见用它来实现自引用结构，主要优点如下:
- 性能高，毕竟直接用裸指针操作
- 代码更简单更符合直觉: 对比下 Option<Rc<RefCell<Node>>>
裸指针：
在计算机科学中，裸指针（Raw Pointer）是一种指针类型，它直接引用内存地址，而不带任何关于内存管理或所有权的附加信息。裸指针在多种编程语言中都有出现，但在像Rust这样的语言中，裸指针的使用特别值得注意，因为它们绕过了Rust的所有权和借用规则，从而可能引入安全问题。
裸指针的特点是：
- 它们不自动进行引用计数，也不跟踪生命周期。
- 它们不保证指向的内存是有效的，使用裸指针可能访问到无效或已释放的内存。
- 它们没有类型信息，所以不能保证指针指向的数据类型。
373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
