Weak<T> 弱引用
什么是 Weak<T>
在使用 Rc<T> 或 Arc<T> 实现共享所有权时,有一个潜在的问题:如果两个 Rc 互相引用,就形成了循环引用(reference cycle)。循环引用会导致引用计数永远不会降到零,数据永远不会被释放,造成内存泄漏。
Weak<T> 就是用来解决这个问题的。它是一种"不拥有数据"的引用——持有 Weak<T> 不会增加强引用计数(strong count),因此不会阻止数据被释放。当你需要引用一份数据但不想"拥有"它时,用 Weak<T>。
Weak<T> 通过 Rc::downgrade 创建,通过 upgrade 方法尝试获取对应的 Rc<T>。因为数据可能已经被释放了,upgrade 返回的是 Option<Rc<T>>——如果数据还在就返回 Some,已经被释放就返回 None。
强引用与弱引用的计数
use std::rc::Rc;
fn main() {
let strong = Rc::new(String::from("数据"));
// 初始状态:强引用 1,弱引用 0
println!("强引用计数: {}", Rc::strong_count(&strong)); // 1
println!("弱引用计数: {}", Rc::weak_count(&strong)); // 0
// 创建一个弱引用
let weak = Rc::downgrade(&strong);
// 弱引用不增加强引用计数
println!("创建 weak 后,强引用计数: {}", Rc::strong_count(&strong)); // 1
println!("创建 weak 后,弱引用计数: {}", Rc::weak_count(&strong)); // 1
// 创建一个强引用
let strong2 = Rc::clone(&strong);
println!("创建 strong2 后,强引用计数: {}", Rc::strong_count(&strong)); // 2
println!("创建 strong2 后,弱引用计数: {}", Rc::weak_count(&strong)); // 1
// 通过弱引用升级为强引用
if let Some(upgraded) = weak.upgrade() {
println!("upgrade 成功: {}", upgraded);
println!("upgrade 后,强引用计数: {}", Rc::strong_count(&strong)); // 3
}
// upgrade 返回的 Rc 离开作用域后,强引用计数恢复
// drop 所有强引用
drop(strong);
drop(strong2);
// 所有强引用都没了,数据已被释放
// 弱引用的 upgrade 返回 None
println!("升级结果: {:?}", weak.upgrade()); // None
}关键规则:
- 强引用计数决定数据何时被释放,降到 0 时数据被 drop
- 弱引用计数只影响 Rc 内部控制块(存储计数器的那块内存)的释放,不影响数据本身
- 弱引用不保证数据还活着,每次使用前必须
upgrade
循环引用问题
先看看没有 Weak 时,循环引用是怎么造成内存泄漏的:
use std::cell::RefCell;
use std::rc::Rc;
// 定义一个可以互相引用的节点
#[derive(Debug)]
struct Node {
value: i32,
// 用 RefCell 允许修改,用 Rc 共享所有权
// 这会导致循环引用!
neighbor: RefCell<Option<Rc<Node>>>,
}
impl Drop for Node {
fn drop(&mut self) {
println!("Node {} 被释放", self.value);
}
}
fn main() {
let node_a = Rc::new(Node {
value: 1,
neighbor: RefCell::new(None),
});
let node_b = Rc::new(Node {
value: 2,
neighbor: RefCell::new(None),
});
// 制造循环引用:A -> B -> A
*node_a.neighbor.borrow_mut() = Some(Rc::clone(&node_b));
*node_b.neighbor.borrow_mut() = Some(Rc::clone(&node_a));
println!("node_a 强引用计数: {}", Rc::strong_count(&node_a)); // 2
println!("node_b 强引用计数: {}", Rc::strong_count(&node_b)); // 2
// 当 node_a 和 node_b 离开作用域时:
// node_a 的强引用计数从 2 降到 1(因为 node_b 的 neighbor 还持有 node_a)
// node_b 的强引用计数从 2 降到 1(因为 node_a 的 neighbor 还持有 node_b)
// 两个都不会降到 0,所以都不会被释放
// "Node 1 被释放" 和 "Node 2 被释放" 都不会打印!
}
// 运行结果:什么都不输出,内存泄漏了用 Weak 打破循环引用
use std::cell::RefCell;
use std::rc::{Rc, Weak};
// 用 Weak 替代 Rc 来存储邻居引用
#[derive(Debug)]
struct Node {
value: i32,
// 改用 Weak,不会增加强引用计数
neighbor: RefCell<Option<Weak<Node>>>,
}
impl Drop for Node {
fn drop(&mut self) {
println!("Node {} 被释放", self.value);
}
}
fn main() {
let node_a = Rc::new(Node {
value: 1,
neighbor: RefCell::new(None),
});
let node_b = Rc::new(Node {
value: 2,
neighbor: RefCell::new(None),
});
// 用 Weak 建立引用:A -> B (weak), B -> A (weak)
*node_a.neighbor.borrow_mut() = Some(Rc::downgrade(&node_b));
*node_b.neighbor.borrow_mut() = Some(Rc::downgrade(&node_a));
// 强引用计数都是 1,没有循环
println!("node_a 强引用计数: {}", Rc::strong_count(&node_a)); // 1
println!("node_b 强引用计数: {}", Rc::strong_count(&node_b)); // 1
// 通过弱引用访问邻居
if let Some(ref weak_neighbor) = *node_a.neighbor.borrow() {
if let Some(neighbor) = weak_neighbor.upgrade() {
println!("node_a 的邻居: Node {}", neighbor.value);
}
}
}
// 输出:
// node_a 强引用计数: 1
// node_b 强引用计数: 1
// node_a 的邻居: Node 2
// Node 2 被释放
// Node 1 被释放树结构:父子关系中的 Weak
树结构是 Weak 最经典的应用场景。父节点用 Rc 持有子节点(拥有关系),子节点用 Weak 指回父节点(观察关系)。
use std::cell::RefCell;
use std::rc::{Rc, Weak};
// 树节点
#[derive(Debug)]
struct TreeNode {
value: String,
// 父节点用 Weak,避免循环引用
// 子节点不应该"拥有"父节点
parent: RefCell<Weak<TreeNode>>,
// 子节点列表用 Rc,父节点拥有子节点
children: RefCell<Vec<Rc<TreeNode>>>,
}
impl TreeNode {
// 创建一个没有父节点的根节点
fn new(value: &str) -> Rc<TreeNode> {
Rc::new(TreeNode {
value: String::from(value),
parent: RefCell::new(Weak::new()),
children: RefCell::new(Vec::new()),
})
}
// 添加子节点,自动设置父子关系
fn add_child(parent: &Rc<TreeNode>, child: &Rc<TreeNode>) {
// 子节点的 parent 指向父节点(弱引用)
*child.parent.borrow_mut() = Rc::downgrade(parent);
// 父节点的 children 包含子节点(强引用)
parent.children.borrow_mut().push(Rc::clone(child));
}
// 获取父节点的值
fn parent_value(&self) -> Option<String> {
// upgrade 弱引用,如果父节点还在就返回它的值
self.parent
.borrow()
.upgrade()
.map(|p| p.value.clone())
}
// 打印树结构
fn print_tree(node: &Rc<TreeNode>, indent: usize) {
let prefix = " ".repeat(indent);
let parent_info = match node.parent_value() {
Some(p) => format!(" (父: {})", p),
None => String::from(" (根节点)"),
};
println!("{}{}{}", prefix, node.value, parent_info);
for child in node.children.borrow().iter() {
TreeNode::print_tree(child, indent + 2);
}
}
}
fn main() {
// 构建一棵树
let root = TreeNode::new("公司");
let tech = TreeNode::new("技术部");
let sales = TreeNode::new("销售部");
let backend = TreeNode::new("后端组");
let frontend = TreeNode::new("前端组");
TreeNode::add_child(&root, &tech);
TreeNode::add_child(&root, &sales);
TreeNode::add_child(&tech, &backend);
TreeNode::add_child(&tech, &frontend);
// 打印树结构
TreeNode::print_tree(&root, 0);
// 验证引用计数
println!("\nroot 强引用: {}, 弱引用: {}", Rc::strong_count(&root), Rc::weak_count(&root));
println!("tech 强引用: {}, 弱引用: {}", Rc::strong_count(&tech), Rc::weak_count(&tech));
// 从子节点访问父节点
println!("\nbackend 的父节点: {:?}", backend.parent_value());
println!("root 的父节点: {:?}", root.parent_value());
}Weak 的常用方法
use std::rc::{Rc, Weak};
fn main() {
// Weak::new() 创建一个不指向任何数据的空弱引用
let empty_weak: Weak<i32> = Weak::new();
println!("空弱引用 upgrade: {:?}", empty_weak.upgrade()); // None
let data = Rc::new(42);
// Rc::downgrade 从 Rc 创建弱引用
let weak = Rc::downgrade(&data);
// upgrade: 尝试升级为 Rc
match weak.upgrade() {
Some(rc) => println!("upgrade 成功: {}", rc),
None => println!("数据已被释放"),
}
// strong_count: 查看弱引用指向的数据的强引用计数
println!("strong_count: {}", weak.strong_count()); // 1
// weak_count: 查看弱引用计数
println!("weak_count: {}", weak.weak_count()); // 1
// ptr_eq: 判断两个弱引用是否指向同一份数据
let weak2 = Rc::downgrade(&data);
println!("ptr_eq: {}", weak.ptr_eq(&weak2)); // true
let other = Rc::new(42);
let weak3 = Rc::downgrade(&other);
println!("不同数据 ptr_eq: {}", weak.ptr_eq(&weak3)); // false
}Arc 中的 Weak
Arc<T> 也有对应的 Weak<T>(在 std::sync 模块中),用法和 Rc 的 Weak 完全一致,但是线程安全的。
use std::sync::{Arc, Weak};
use std::thread;
fn main() {
let data = Arc::new(String::from("跨线程数据"));
// 从 Arc 创建弱引用
let weak: Weak<String> = Arc::downgrade(&data);
let handle = thread::spawn(move || {
// 在另一个线程中尝试升级弱引用
match weak.upgrade() {
Some(arc) => println!("子线程获取到数据: {}", arc),
None => println!("子线程: 数据已被释放"),
}
});
// 主线程仍然持有 data
println!("主线程: {}", data);
handle.join().unwrap();
}基本示例
一个综合示例:用 Weak 实现双向链表。
use std::cell::RefCell;
use std::rc::{Rc, Weak};
use std::fmt;
// 双向链表节点
struct DNode<T> {
value: T,
// 指向前一个节点:用 Weak 避免循环引用
prev: RefCell<Option<Weak<DNode<T>>>>,
// 指向后一个节点:用 Rc 拥有下一个节点
next: RefCell<Option<Rc<DNode<T>>>>,
}
// 双向链表
struct DoublyLinkedList<T> {
head: Option<Rc<DNode<T>>>,
tail: Option<Rc<DNode<T>>>,
length: usize,
}
impl<T: fmt::Display> DoublyLinkedList<T> {
fn new() -> Self {
DoublyLinkedList {
head: None,
tail: None,
length: 0,
}
}
// 在尾部添加节点
fn push_back(&mut self, value: T) {
let new_node = Rc::new(DNode {
value,
prev: RefCell::new(None),
next: RefCell::new(None),
});
match self.tail.take() {
Some(old_tail) => {
// 新节点的 prev 指向旧尾部(弱引用)
*new_node.prev.borrow_mut() = Some(Rc::downgrade(&old_tail));
// 旧尾部的 next 指向新节点(强引用)
*old_tail.next.borrow_mut() = Some(Rc::clone(&new_node));
self.tail = Some(new_node);
}
None => {
// 空链表,head 和 tail 都指向新节点
self.head = Some(Rc::clone(&new_node));
self.tail = Some(new_node);
}
}
self.length += 1;
}
// 在头部添加节点
fn push_front(&mut self, value: T) {
let new_node = Rc::new(DNode {
value,
prev: RefCell::new(None),
next: RefCell::new(None),
});
match self.head.take() {
Some(old_head) => {
// 旧头部的 prev 指向新节点(弱引用)
*old_head.prev.borrow_mut() = Some(Rc::downgrade(&new_node));
// 新节点的 next 指向旧头部(强引用)
*new_node.next.borrow_mut() = Some(old_head);
self.head = Some(new_node);
}
None => {
self.head = Some(Rc::clone(&new_node));
self.tail = Some(new_node);
}
}
self.length += 1;
}
// 正向遍历打印
fn print_forward(&self) {
print!("正向: ");
let mut current = self.head.clone();
while let Some(node) = current {
print!("{}", node.value);
current = node.next.borrow().clone();
if current.is_some() {
print!(" <-> ");
}
}
println!();
}
// 反向遍历打印
fn print_backward(&self) {
print!("反向: ");
let mut current = self.tail.clone();
while let Some(node) = current {
print!("{}", node.value);
// 从 Weak 升级到 Rc 来访问前一个节点
current = node.prev.borrow().as_ref().and_then(|w| w.upgrade());
if current.is_some() {
print!(" <-> ");
}
}
println!();
}
}
fn main() {
let mut list = DoublyLinkedList::new();
list.push_back(1);
list.push_back(2);
list.push_back(3);
list.push_front(0);
println!("链表长度: {}", list.length);
list.print_forward(); // 正向: 0 <-> 1 <-> 2 <-> 3
list.print_backward(); // 反向: 3 <-> 2 <-> 1 <-> 0
// 验证没有内存泄漏:检查引用计数
if let Some(ref head) = list.head {
println!("head 强引用: {}", Rc::strong_count(head));
println!("head 弱引用: {}", Rc::weak_count(head));
}
}所有权方向的设计原则
使用 Weak 时最重要的设计原则是:所有权必须是单向的。
正确的设计模式:
树结构:
父 --[Rc]--> 子
子 --[Weak]--> 父
双向链表:
前 --[Rc]--> 后
后 --[Weak]--> 前
观察者模式:
被观察者 --[Weak]--> 观察者
观察者 --[Rc]--> 被观察者(或反过来,取决于谁拥有谁)
错误的设计(会导致循环引用):
A --[Rc]--> B
B --[Rc]--> A ← 两个都是强引用,形成循环常见问题
问题一:什么时候用 Rc,什么时候用 Weak?
判断标准是所有权关系:如果 A 应该"拥有" B(B 的生命依赖于 A),用 Rc。如果 A 只是"观察" B(A 不应该阻止 B 被释放),用 Weak。在有双向引用的场景中,至少一个方向必须用 Weak,否则会形成循环。
问题二:upgrade 返回 None 说明什么?
说明弱引用指向的数据已经被释放了——所有强引用都已经被 drop。这是完全正常的行为,你的代码需要处理这种情况。这也是 upgrade 返回 Option 而不是直接返回 Rc 的原因——Rust 强制你考虑"数据可能已经不在了"这种可能性。
问题三:Weak 和裸指针有什么区别?
| 特性 | Weak<T> | *const T(裸指针) |
|---|---|---|
| 安全性 | 安全,upgrade 返回 Option | 不安全,解引用可能是悬垂指针 |
| 检测数据是否有效 | 可以(upgrade 返回 None) | 不可以 |
| 内存管理 | 自动管理 | 需要手动管理 |
| 使用 unsafe | 不需要 | 需要 |
问题四:弱引用计数有什么用?
弱引用计数控制的是 Rc 内部控制块(存储强引用计数和弱引用计数的那块内存)的释放时机。当强引用计数归零时,数据(T)被释放;当强引用计数和弱引用计数都归零时,控制块也被释放。所以即使数据已经被释放了,只要还有 Weak 存在,控制块就还在内存中。
适用场景
- 树结构的父子关系:子节点用 Weak 指向父节点,避免循环引用
- 双向链表:反向链接用 Weak,正向链接用 Rc
- 观察者模式:被观察者持有观察者的弱引用,观察者被释放后自动失效
- 缓存系统:缓存持有数据的弱引用,数据在其他地方被释放后,缓存条目自动失效
- 图结构中的回边:图中可能形成环的边用 Weak 表示
- GUI 框架中的组件关系:子组件引用父窗口,用 Weak 避免父窗口无法被释放
注意事项
Weak<T>不会阻止数据被释放,每次使用前必须upgrade并处理None的情况Weak::new()创建的空弱引用,upgrade永远返回NoneWeak<T>在数据被释放后仍然占用少量内存(控制块),直到所有Weak也被 drop- 设计数据结构时,先确定所有权的方向,再决定哪些引用用
Rc、哪些用Weak Rc的Weak不能跨线程,跨线程场景用Arc的Weak(std::sync::Weak)- 循环引用导致的内存泄漏在 Rust 中是"安全的"——不会产生未定义行为,只是浪费内存
- 不要把所有引用都改成
Weak,只有可能形成循环的那条边才需要用Weak
总结
Weak<T> 是 Rc<T> 和 Arc<T> 的配套工具,用于解决共享所有权中的循环引用问题。它持有一个不增加强引用计数的"弱"引用,不会阻止数据被释放。使用 Weak 前必须通过 upgrade() 尝试获取 Rc,如果数据已经被释放就返回 None。设计含有双向引用的数据结构时,核心原则是"所有权单向流动"——一个方向用 Rc(拥有),另一个方向用 Weak(观察)。最典型的应用是树结构中的父子关系和双向链表中的前后链接。Weak 不是万能的——它只解决循环引用问题,如果你的数据结构没有形成环的风险,就不需要用 Weak。