Rust 中的引用循环与内存泄漏
一、引用计数与引用循环
在 Rust 中，Rc<T> 允许多个所有者共享同一个数据，当调用 Rc::clone 时，会增加内部的引用计数（strong_count）。只有当引用计数降为 0 时，对应的内存才会被释放。
然而，如果你创建了一个引用循环，比如两个或多个值互相引用对方，那么每个值的引用计数都不会降为 0，从而导致这些内存永远无法被回收。这种情况虽然不会导致程序崩溃，但在长期运行或者大量数据累积时，可能会耗尽系统内存。
1.1. 示例：使用 Rc<T> 和 RefCell<T> 创建引用循环
考虑下面的代码片段，我们定义了一个类似于链表的 List 枚举，其中 Cons 变体不仅存储一个整数，还通过 RefCell<Rc<List>> 保存对下一个节点的引用：
enum List {
Cons(i32, RefCell<Rc<List>>),
Nil,
}
impl List {
fn tail(&self) -> Option<&RefCell<Rc<List>>> {
match self {
List::Cons(_, tail) => Some(tail),
List::Nil => None,
}
}
}
在 main 函数中，我们创建了两个 Rc<List> 实例 a 和 b，并通过修改 a 中保存的指针让其指向 b，从而形成一个循环引用：
fn main() {
let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));
println!("a 的引用计数 = {}", Rc::strong_count(&a));
let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a))));
println!("a 的引用计数 = {}", Rc::strong_count(&a));
println!("b 的引用计数 = {}", Rc::strong_count(&b));
if let Some(link) = a.tail() {
*link.borrow_mut() = Rc::clone(&b);
}
// 此时，a 和 b 互相引用，形成循环
println!("a 的引用计数 = {}", Rc::strong_count(&a));
println!("b 的引用计数 = {}", Rc::strong_count(&b));
// 如果在此处尝试打印整个列表，会因为无限循环而导致栈溢出
// println!("a = {:?}", a);
}
在这段代码中，最初 a 与 b 的引用计数分别为 1 和 1；但在将 a 的 tail 修改为指向 b 后，两个节点的引用计数都增加到 2。当 main 结束时，即使局部变量 a 和 b 离开作用域，但由于互相引用，它们内部的引用计数仍然大于 0，导致内存无法被释放。
二、解决方法：使用弱引用（Weak<T>）
为了解决引用循环问题，Rust 提供了 Weak<T> 类型。与 Rc<T> 不同，Weak<T> 并不表达所有权，它的存在不会增加引用计数，也就不会阻止值的释放。
2.1. 应用场景：树形结构
在树形结构中，父节点通常拥有子节点，而子节点也可能需要引用父节点。如果使用 Rc<T> 建立双向引用，会产生循环引用问题。解决方案是让子节点通过 Weak<T> 来引用父节点，这样即使父节点与子节点互相引用，只有所有的强引用（Rc<T>）被释放时，对象才能被正确销毁。
下面是一个简单的示例，展示了如何在节点结构体中使用弱引用来避免循环引用：
use std::rc::{Rc, Weak};
use std::cell::RefCell;
#[derive(Debug)]
struct Node {
value: i32,
parent: RefCell<Weak<Node>>,
children: RefCell<Vec<Rc<Node>>>,
}
impl Node {
fn new(value: i32) -> Rc<Node> {
Rc::new(Node {
value,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![]),
})
}
}
fn main() {
// 创建一个没有父节点的叶子节点
let leaf = Node::new(3);
println!("leaf 的 parent = {:?}", leaf.parent.borrow().upgrade());
{
// 在内部作用域中创建一个分支节点，将叶子节点作为其子节点
let branch = Node::new(5);
*leaf.parent.borrow_mut() = Rc::downgrade(&branch);
branch.children.borrow_mut().push(Rc::clone(&leaf));
println!("branch 的引用计数 = {}, 弱引用计数 = {}",
Rc::strong_count(&branch),
Rc::weak_count(&branch)
);
println!("leaf 的引用计数 = {}, 弱引用计数 = {}",
Rc::strong_count(&leaf),
Rc::weak_count(&leaf)
);
}
// 此时，branch 已经离开作用域被释放，leaf 的 parent 升级后为 None
println!("leaf 的 parent = {:?}", leaf.parent.borrow().upgrade());
println!("leaf 的引用计数 = {}", Rc::strong_count(&leaf));
}
在这个例子中：
- 我们用
Rc::downgrade创建了指向branch的弱引用，并将其赋值给leaf的parent字段。 - 由于
Weak<T>不增加强引用计数，即使branch离开作用域后被销毁，leaf也不会阻止内存回收。 - 当尝试使用
upgrade获取leaf的父节点时，如果对应的Rc<Node>已被销毁，将返回None。
这种设计使得父子节点之间的关系更符合实际的所有权语义：父节点拥有子节点，而子节点仅仅持有对父节点的一个“非所有权”引用，从而避免了引用循环和潜在的内存泄漏问题。
三、总结
在本文中，我们讨论了在 Rust 中如何利用 Rc<T> 与 RefCell<T> 创建引用循环，以及这种循环如何导致内存泄漏。虽然 Rust 的内存安全性保证可以防止悬垂指针等常见问题，但引用循环仍然可能悄无声息地引起内存泄漏。为了解决这一问题，我们引入了 Weak<T> 类型，使得我们可以在需要双向引用（如树结构中父子关系）的场景下避免循环引用问题。
理解和掌握这些智能指针（Box<T>、Rc<T>、RefCell<T> 和 Weak<T>）的细微差别，对于编写高效且内存安全的 Rust 程序至关重要。希望这篇博客能帮助你更深入地理解 Rust 中的引用计数和内存管理机制，并在未来的项目中避免潜在的内存泄漏问题。