当前位置：首页 > news >正文

Rust专项——用 Weak 打破引用环：树与图结构实战

news 2025/10/31 8:10:42

在 Rc/Arc 的共享结构中，强引用彼此指向会形成引用环，导致内存无法回收。Weak 是用于打破环的“弱引用”，它不会增加强计数，必要时通过 upgrade() 临时获取 Rc/Arc。

1. 为什么会泄漏？（最小示例）

use std::rc::Rc;
use std::cell::RefCell;#[derive(Debug)]
struct Node { next: RefCell<Option<Rc<Node>>> }fn leak_demo() {let a = Rc::new(Node { next: RefCell::new(None) });let b = Rc::new(Node { next: RefCell::new(None) });*a.next.borrow_mut() = Some(Rc::clone(&b));*b.next.borrow_mut() = Some(Rc::clone(&a)); // a<->b 强引用形成环println!("strong_count a={}, b={}", Rc::strong_count(&a), Rc::strong_count(&b));// 函数结束后 strong_count 仍>0，内存泄漏！
}

结论：在双向（或环形）结构使用 Rc 强引用，若没有弱引用参与，必然泄漏。

2. 正确用法：父子树结构（父->子 Rc，子->父 Weak）

use std::rc::{Rc, Weak};
use std::cell::RefCell;#[derive(Debug)]
struct Node {val: i32,parent: RefCell<Weak<Node>>,             // 子指回父：Weakchildren: RefCell<Vec<Rc<Node>>>,        // 父指向子：Rc
}fn tree_demo() {let root = Rc::new(Node { val: 0, parent: RefCell::new(Weak::new()), children: RefCell::new(Vec::new()) });let child = Rc::new(Node { val: 1, parent: RefCell::new(Weak::new()), children: RefCell::new(Vec::new()) });child.parent.replace(Rc::downgrade(&root));root.children.borrow_mut().push(Rc::clone(&child));println!("root_strong={}, root_weak={}", Rc::strong_count(&root), Rc::weak_count(&root));println!("child_strong={}, child_weak={}", Rc::strong_count(&child), Rc::weak_count(&child));// 升级 Weak -> Rcif let Some(parent) = child.parent.borrow().upgrade() {println!("child.parent.val={}", parent.val);}
}

约定俗成：父->子强引用、子->父弱引用。这样父子都释放时环自动解开。

3. 图结构：双向边的弱引用策略

对于图（Graph），可以：
- 顶点 Rc<Vertex>；
- 边保存到对端的 Weak<Vertex>，访问前 upgrade()；
- 若升级失败，说明对端已释放。

#[derive(Debug)]
struct Vertex { id: usize, peers: RefCell<Vec<Weak<Vertex>>> }fn graph_demo() {let v1 = Rc::new(Vertex { id: 1, peers: RefCell::new(vec![]) });let v2 = Rc::new(Vertex { id: 2, peers: RefCell::new(vec![]) });v1.peers.borrow_mut().push(Rc::downgrade(&v2)); // 弱引用记录邻居v2.peers.borrow_mut().push(Rc::downgrade(&v1));// 枚举邻居for p in v1.peers.borrow().iter() {if let Some(peer) = p.upgrade() { println!("v1 -> {}", peer.id); }}
}

4. Arc 场景下的 Weak（并发）

并发下的共享结构也同理，用 Arc<Mutex<T>> 或 Arc<RwLock<T>> 搭配 Weak<T>：

use std::sync::{Arc, Weak, Mutex};
#[derive(Debug)]
struct Hub { slots: Mutex<Vec<Weak<Hub>>> }

仅在需要时 upgrade()，并检查是否还活着。

5. 模式总结与选型

场景	强引用	弱引用	说明
父子树结构	父 -> 子：Rc/Arc	子 -> 父：Weak	断环、防泄漏
双向链表/图	任意一侧改 Weak	另一侧 Rc/Arc	访问时 `upgrade()` 检查
并发共享	`Arc` + `Mutex/RwLock`	`Weak`	升级检查，避免悬垂

6. 常见坑与修复

所有边都用 Rc/Arc 导致泄漏 → 一侧改 Weak；
upgrade() 忘记判空 → 可能 None；
结构嵌套多层 RefCell 导致运行时借用冲突 → 合理拆分与缩小借用范围；
并发下用 Rc → 崩溃；请用 Arc。

7. 完整示例：目录树（父/子/打印路径）

use std::rc::{Rc, Weak};
use std::cell::RefCell;#[derive(Debug)]
struct Dir {name: String,parent: RefCell<Weak<Dir>>,children: RefCell<Vec<Rc<Dir>>>,
}impl Dir {fn new(name: &str) -> Rc<Self> {Rc::new(Dir {name: name.into(),parent: RefCell::new(Weak::new()),children: RefCell::new(vec![]),})}fn add_child(parent: &Rc<Dir>, name: &str) -> Rc<Dir> {let child = Dir::new(name);child.parent.replace(Rc::downgrade(parent));parent.children.borrow_mut().push(Rc::clone(&child));child}fn path(node: &Rc<Dir>) -> String {let mut names = vec![node.name.clone()]; // 克隆 name 的值而不是获取引用let mut cur = node.parent.borrow().upgrade();while let Some(p) = cur {names.push(p.name.clone()); // 克隆 name 的值cur = p.parent.borrow().upgrade();}names.into_iter().rev().collect::<Vec<_>>().join("/")}
}fn main() {let root = Dir::new("/");let etc = Dir::add_child(&root, "etc");let nginx = Dir::add_child(&etc, "nginx");println!("{}", Dir::path(&nginx));// 输出: //etc/nginx（示例）
}