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。

强引用与弱引用的计数 ​

rust
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 时,循环引用是怎么造成内存泄漏的:

rust
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 打破循环引用 ​

rust
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 指回父节点(观察关系)。

rust
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 的常用方法 ​

rust
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 完全一致,但是线程安全的。

rust
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 实现双向链表。

rust
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 时最重要的设计原则是:所有权必须是单向的。

text
正确的设计模式:

树结构:
  父 --[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 永远返回 None
  • Weak<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。