避免循环引用的 Weak 弱指针:树与图结构中的内存防泄漏实践

Go 1.24 新特性解析:泛型类型别名、弱指针与终结器改进 这些改进体现了 Go 在保持简洁性的同时,逐步增强工程化能力的路线。开发者可根据具体场景选择合适的新特性,但需始终牢记 Go 的哲学:“Simple is better than complex.”Go 1.24 允许为泛型类型定义别名,简化复杂类型的声明。不同于传统类型别名,泛型别名保留原始类型的所有方法,同时支持参数化类型约束。这些特性进一步提升了类型系统的灵活性、内存管理能力和资源回收可靠性。类型实现弱引用指针。弱指针不会阻止垃圾回收器回收目标对象,避免因循环引用导致的内存泄漏。 阅读详情

避免循环引用的 Weak 弱指针:树与图结构中的内存防泄漏实践

封面信息图

在前面的学习中,我们掌握了使用 Rc<T> 和 Arc<T> 来实现单线程或跨线程的多所有权共享。每当我们克隆一个智能指针时,其强引用计数(strong_count)就会加 1;当指针离开作用域时,强引用计数减 1。只有当强引用计数归零时,底层堆内存才会被确定性地 drop 释放。

然而,在构建复杂数据结构(如 DOM 树、网络拓扑图、会话依赖图以及 AST 语法树)时,经常会出现父子节点相互持有引用、或者多个节点形成环形回路的情况。

如果两个节点互相持有对方的 Rc<T> 或 Arc<T>,它们的强引用计数将永远不会降到 0!这会导致堆内存在程序整个生命周期内永远无法被回收,从而造成隐蔽的内存泄漏(Memory Leak)。

为了打破这种循环引用死结,Rust 标准库引入了 Rc::downgrade / Arc::downgrade 以及 Weak<T> 弱引用智能指针。今天这篇文章,我们来深入剖析弱引用的内存模型与防泄漏最佳实践。


1. 循环引用导致内存泄漏的物理现场

看下面这个典型的父子节点相互引用的翻车案例:

use std::cell::RefCell;
use std::rc::Rc;

struct Node {
    name: String,
    // 子节点持有父节点的强引用(致命循环引用!)
    parent: RefCell<Option<Rc<Node>>>,
    children: RefCell<Vec<Rc<Node>>>,
}

fn create_leak() {
    let parent = Rc::new(Node {
        name: "Parent".to_string(),
        parent: RefCell::new(None),
        children: RefCell::new(Vec::new()),
    });

    let child = Rc::new(Node {
        name: "Child".to_string(),
        parent: RefCell::new(Some(Rc::clone(&parent))), // child 强引用 parent
        children: RefCell::new(Vec::new()),
    });

    // parent 强引用 child
    parent.children.borrow_mut().push(Rc::clone(&child));

    println!("Parent 强引用计数: {}", Rc::strong_count(&parent)); // 输出 2
    println!("Child 强引用计数: {}", Rc::strong_count(&child));   // 输出 2
} // 函数结束,栈上的 parent 和 child 变量弹栈,强引用计数各自减 1,都变成 1!
  // 堆内存永远无法归零,内存彻底泄露!
       ┌───────────────┐
       │  Parent Node  │ ◄───────┐
       │ (strong: 1)   │         │ (child.parent 强引用)
       └───────┬───────┘         │
               │                 │
(parent.children 强引用)           │
               │                 │
               ▼                 │
       ┌───────────────┐         │
       │  Child Node   │ ────────┘
       │ (strong: 1)   │
       └───────────────┘

2. Weak 弱指针的救赎之道

Weak<T> 是一种**不表达所有权(Non-owning Reference)**的智能指针:

  • 它通过 Rc::downgrade(&rc) 或 Arc::downgrade(&arc) 生成;
  • 它只会增加堆上的弱引用计数(weak_count),绝对不会增加强引用计数;
  • 只要强引用计数降为 0,底层对象的数据就会被立即销毁,即使此时 weak_count 依然大于 0!
黄金法则:父对子用强引用(Rc/Arc),子对父用弱引用(Weak)
use std::cell::RefCell;
use std::rc::{Rc, Weak};

struct SafeNode {
    name: String,
    // 关键改造:子节点持有指向父节点的 Weak 弱引用!
    parent: RefCell<Weak<SafeNode>>,
    children: RefCell<Vec<Rc<SafeNode>>>,
}

impl Drop for SafeNode {
    fn drop(&mut self) {
        println!(" [析构] 节点 '{}' 已被成功回收!", self.name);
    }
}

fn demonstrate_safe_tree() {
    let parent = Rc::new(SafeNode {
        name: "Parent".to_string(),
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(Vec::new()),
    });

    let child = Rc::new(SafeNode {
        name: "Child".to_string(),
        // 使用 downgrade 创建弱指针
        parent: RefCell::new(Rc::downgrade(&parent)),
        children: RefCell::new(Vec::new()),
    });

    parent.children.borrow_mut().push(Rc::clone(&child));

    println!("Parent 强引用: {}, 弱引用: {}", Rc::strong_count(&parent), Rc::weak_count(&parent));
    println!("Child 强引用: {}, 弱引用: {}", Rc::strong_count(&child), Rc::weak_count(&child));
}

运行该函数,当离开作用域时,控制台立刻打印出:

Parent 强引用: 1, 弱引用: 1
Child 强引用: 2, 弱引用: 0
 [析构] 节点 'Parent' 已被成功回收!
 [析构] 节点 'Child' 已被成功回收!

内存被 100% 完美释放,零泄漏!


3. 如何安全访问 Weak 内部的数据?

因为 Weak<T> 指向的对象随时可能已经被释放销毁,所以你无法直接对 Weak<T> 进行解引用。

必须调用其 upgrade() 方法:

  • 如果底层对象仍然存活,upgrade() 返回 Some(Rc<T>)(并将强引用计数临时加 1,保证在访问期间对象不会被释放);
  • 如果底层对象已被析构,upgrade() 返回 None。
fn print_parent_name(child: &SafeNode) {
    let weak_parent = child.parent.borrow();
    
    // 尝试升级为强引用
    if let Some(strong_parent) = weak_parent.upgrade() {
        println!("父节点名称为: {}", strong_parent.name);
    } else {
        println!("父节点已经被释放销毁!");
    }
}

4. 抓包分析器中的实战应用:TCP 双向会话流(Bidi-Flow Tracker)

在我们的抓包特征过滤引擎中,一个 TCP 连接包含两个单向流(Forward Flow: Client -> Server 与 Reverse Flow: Server -> Client)。它们需要互相感知对端的序列号确认情况:

use std::sync::{Arc, RwLock, Weak};

pub struct SingleFlow {
    pub flow_id: u64,
    pub bytes_sent: usize,
    // 弱引用指向对端反向流,防止双向 Arc 循环死锁与内存泄露
    pub peer_flow: RwLock<Weak<SingleFlow>>,
}

impl SingleFlow {
    pub fn new(id: u64) -> Self {
        Self {
            flow_id: id,
            bytes_sent: 0,
            peer_flow: RwLock::new(Weak::new()),
        }
    }

    pub fn check_peer_activity(&self) -> Option<usize> {
        let guard = self.peer_flow.read().unwrap();
        guard.upgrade().map(|peer| peer.bytes_sent)
    }
}

总结

Weak<T> 是 Rust 智能指针家族中优雅打破强引用闭环的必备利器:

  • 树结构、图拓扑、双向关联关系中,一律使用“一强一弱”;
  • 弱引用不阻止析构,强引用归零时内存即刻释放;
  • 必须通过 upgrade() 显式处理对象可能已被回收的 Option 场景,彻底掐死野指针。
深入学习c++--智能指针(二) weak_ptr (打破shared_ptr循环引用) 目录 1. 几种智能指针 1.1 weak_ptr 1.2 weak_ptr基本用法 1.3 解决类之间循环引用 1.4用 enable_shared_from_this从this转换到shared_ptr 1. 几种智能指针 1. auto_ptr: c++11中推荐不使用他(放弃) 2.shared_ptr:每添加一次引用 就+1,减少一次引用,就-1;做到指针进行共享 ... 阅读详情

相关推荐

【C++11】weak_ptr智能指针使用详解

在C++编程中,处理循环引用是一个常见的问题。循环引用可能导致内存泄漏和资源管理问题。为了解决这个问题,C++11引入了weak_ptr智能指针。弱指针(weak_ptr)是一种不受控制所指向对象生存期的智能指针,它指向由一个shared_ptr管理的对象。允许你共享对象的所有权,但不会增加对象的引用计数。它是一种弱引用,不会阻止对象的销毁。一旦一个指向对象的shared_ptr被销毁,对象就会被释放。即使有weak_ptr指向对象,对象也会被释放。

xiaofeizai1116的博客 1177

weak_ptr基本用法以及怎么解决循环引用

文章主要记录自己学习智能指针weak_ptr的笔记,详细记录了weak_ptr处理循环引用的步骤,并且写了weak_ptr常用的函数用法以及注意事项。

m0_70418130的博客 7465

C++11智能指针实战:weak_ptr、循环引用与多线程安全

智能指针是现代C++内存管理的核心机制,通过自动化资源释放来避免内存泄漏。其核心原理基于RAII(资源获取即初始化)和所有权语义,其中unique_ptr实现独占所有权,shared_ptr通过引用计数实现共享所有权。这一机制的技术价值在于显著提升代码安全性和可维护性,减少手动内存管理错误。在实际应用场景中,智能指针广泛用于工厂模式、观察者模式、Pimpl惯用法等设计模式实现。然而,shared_ptr的循环引用问题需要通过weak_ptr解决,而多线程环境下引用计数的原子操作虽保证控制块安全,但对象访问仍

weixin_33462167的博客 349

【C/C++】强弱指针如何打破循环引用避免内存泄漏 ?

shared_ptr和weak_ptr区别以及内存泄露机制与如何避免。

qq_51482778的博客 1127

别再让电池充不满!用CN3791芯片设计太阳能充电电路,这几个调试坑我帮你踩了

本文详细解析了使用CN3791芯片设计太阳能充电电路时的常见调试问题及解决方案。从RCS电阻的选择到MPPT电压偏差的修正,再到线路损耗和温度补偿的优化,提供了全面的避坑指南。通过实测数据和优化方案,帮助工程师提升锂电池充电效率,确保太阳能充电电路的稳定性和可靠性。

weixin_42528191的博客 244

《Hadoop大数据技术原理与应用》(第2版)黑马程序员的课后习题答案

《Hadoop大数据技术原理与应用》(第2版)黑马程序员的课后习题答案

qq_36773158的博客 4656

c++弱引用指针std::weak_ptr作用详解

摘要 本文深入解析C++中std::weak_ptr的设计原理与应用场景。作为std::shared_ptr的补充,weak_ptr通过"只观察不持有"的特性解决了智能指针的两大痛点:循环引用导致的内存泄漏和安全访问已销毁对象的问题。文章首先通过类比形象说明两者的区别,然后剖析了weak_ptr基于控制块计数器的实现机制,包括use_count和weak_count的作用。最后通过父子对象循环引用和资源缓存两个典型案例,展示了weak_ptr在实际工程中的应用价值,包括如何通过lock(

猫哥 的沉淀、积累、总结。天天学习,好好向上...c/c++,嵌入式 linux,Android,HarmonyOS,AIOT) 1465

ESP-01S获取网络时间踩坑全记录:AT指令调试、JSON解析乱码、时区处理,一个都不能少

本文详细记录了使用ESP-01S WIFI模块获取网络时间的完整过程,包括AT指令调试、JSON解析乱码处理以及时区转换等关键步骤。通过实战案例和代码示例,帮助开发者避开常见陷阱,实现稳定的网络时间同步功能。

weixin_30460489的博客 295

智能指针进阶:从shared_ptr到weak_ptr,破解循环引用的终极方案

摘要:本文深入解析C++中shared_ptr循环引用的成因及解决方案。通过介绍shared_ptr控制块结构和引用计数机制,分析双向链表等场景下循环引用导致的内存泄漏问题。重点探讨weak_ptr如何作为"弱观察者"打破循环,并详细讲解std::enable_shared_from_this正确获取this指针shared_ptr的方法。最后给出智能指针使用的三条安全法则:用weak_ptr避免循环引用、安全获取this指针、理解控制块原理。(148字)

huahua8088的博客 990

软件测试面试题汇总

软件测试面试题汇总 测试技术面试题 ........................................................................................................................................................................ 5 1、什么是兼容

晴天的专栏 2万+

c++通过自然语言处理技术分析语音信号音高

其中,缓冲区大小为2048,最小基频为80Hz,最大基频为1000Hz。通常情况下,音高在85Hz到255Hz之间,因此可以根据实际情况修改最小和最大基频值。C++中可以使用数字信号处理库或语音处理库,比如MATLAB、Praat、YIN算法等等来进行音高分析。对于语音信号的音高分析,可以使用基频提取技术。基频是指一个声音周期的重复率,也就是一个声音波形中最长的周期。通常情况下,人的声音基频范围是85Hz到255Hz。这段代码使用了YIN算法来计算语音信号的基频,得出的结果即为音高。

SYC20110120的博客 1729

【深入理解C++】weak_ptr以及为什么能解决循环引用

是一种不增加引用计数的智能指针,通常与shared_ptr一起使用,用于解决循环引用问题。循环引用问题:当两个或多个shared_ptr相互引用时,引用计数无法归零,导致对象无法被销毁,最终可能导致内存泄漏。weak_ptr解决方案:通过将其中一个shared_ptr替换为weak_ptr,可以打破循环引用。weak_ptr不会增加引用计数,因此当没有shared_ptr指向对象时,引用计数会降为 0,对象会被销毁,从而避免内存泄漏。使用weak_ptr。

m0_69378371的博客 1172

python基础:工作会用到的95%的基础python代码都在这了(万字详解!)

本文是一份Python编程语言的快速参考备忘单,涵盖了Python基础语法和常用数据类型。主要内容包括:Python入门指南(打印、变量声明)、内置数据类型(字符串、数值、列表、元组、集合、字典等)、控制结构(判断、循环)、函数定义、文件处理操作以及字符串操作方法(切片、循环遍历等)。这个备忘单特别适合初学者快速查阅Python基础语法,同时也提供了数据类型转换、f-string格式化字符串等实用技巧。通过简洁的代码示例展示了Python的基本语法规则和典型用法。

数据知道的博客 8165

shared_ptr造成的循环引用&&解决方法和原理(弱引用&&强引用)

内存泄漏及浪费都是每个程序员非常忌讳的事情,但是稍有不慎就会造成不可弥补的损失,这里就这能指针sheard_ptr造成的循环引用及造成循环引用的原因我给大家给出了详细的图解及举例说明,同时也提供了避免这种循环引用的解决办法,就针对弱引用这一点做出了详细的解释,就针对shared_ptr和weak_ptr这两种智能指针的作用和用法也相加说明使得读者可以从代码及图例两方面对循环引用及解决办法有更深的认识。

yc2zgh1314的博客 1万+

数据分析案例-对某宝用户评论做情感分析

目录 原始数据 绘制词云图 情感分析 原始数据 原始数据为某宝一商品的用户评论数据 绘制词云图 # coding=utf-8 import jieba import re import wordcloud import imageio # 打开需要分析词频的文本 with open('淘宝评论3.0.txt', encoding='utf-8') as f: data = f.read() # 文本预处理 :去除一些无用的字符只提取出中文出来 new_data

m0_64336780的博客 1万+

绿米Aqara S1【妙控开关 S1E】版本降级或升级自定义固件的方法

绿米Aqara S1【妙控开关 S1E】版本降级或升级自定义固件的方法

LeeKwen的专栏 2188

C++智能指针和内存泄漏

本文系统介绍了C++智能指针的核心概念与应用。首先分析了传统指针在异常处理时容易导致内存泄漏的问题,阐述了RAII(资源获取即初始化)设计思想,指出智能指针通过对象生命周期管理资源。详细讲解了标准库提供的auto_ptr(已废弃)、unique_ptr(独占所有权)、shared_ptr(共享所有权)和weak_ptr(解决循环引用)四种智能指针的特性与适用场景。通过代码示例展示了智能指针的实现原理,重点剖析了shared_ptr的引用计数机制。文章还探讨了智能指针与内存泄漏的关系,比较了C++11与Boo

keyipatience的博客 871

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

智能指针循环引用问题

智能指针循环引用 循环引用简单来说就是:两个对象互相使用一个shared_ptr成员变量指向对方,这会造成循环引用。导致引用计数失效,内存无法释放。 #include <iostream> #include <memory> class CB; class CA { public: CA() { std::cout << "CA()" << std::endl; } ~CA() { std::cout <&lt

qq_36553387的博客 2647

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

@property的属性 strong 和 weak 深刻理解(强引用与弱引用)

在Objective-C里,用@property访问所有的实例变量。@property有一对属性:strong 和 weak。官方文档里的解释晦涩难懂;Stack Overflow里的用户RDC (http://stackoverflow.com/users/1371853/rdc) 给出了形象的解释: 把对象想象成一条狗,它要跑 (be deallocated)。强指针就像一条拴在狗脖

spark_csdn的博客 3293

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

一文弄懂什么是内存泄漏

内存泄漏(memory leak),是指由于疏忽或错误造成了程序未能释放掉不再使用的内存的情况。内存泄漏并非指内存在物理上的消失,而是应用程序分配某段内存后,由于设计错误,失去了对该段内存的控制,因而造成了内存的浪费或者性能不良的情况。

实践出真理,接毕设/课设项目开发指导 1757

弱引用能指针 weak_ptr

弱引用智能指针std::weak_ptr可以看做是shared_ptr的助手,它不管理shared_ptr内部的指针。std::weak_ptr没有重载操作符*和->,因为它不共享指针,不能操作资源,所以它的构造不会增加引用计数,析构也不会减少引用计数,它的主要作用就是作为一个旁观者监视shared_ptr中管理的资源是否存在。

f593256的博客 606

C++ 中的循环引用问题及其解决方案

循环引用是指两个或多个对象之间相互引用,形成一个引用环。例如,有两个类ClassA和ClassBClassA中有一个ClassB类型的成员变量,而ClassB中也有一个ClassA类型的成员变量。// ClassA 中包含一个指向 ClassB 的指针public:ClassA* a;// ClassB 中包含一个指向 ClassA 的指针在这个例子中,ClassA和ClassB相互引用,形成了一个循环引用。

llookl的博客 1149

C++循环引用,如何解决

另一种方法是在合适的时候手动打破循环引用。例如,在对象的析构函数或者其他合适的生命周期结束的方法中,将相互引用的指针设置为nullptr。这种方法需要谨慎设计对象的生命周期和引用关系,确保在正确的时间点打破循环引用,避免内存泄漏和资源浪费。

2301_77891039的博客 747

shellmad-23_C++新特性 weak_ptr的提出及解决循环引用的思路

深入分析shared_ptr与weak_ptr的实现 stl中使用了shared_ptr来管理一个对象的内部指针,并且使用了weak_ptr来防止前面所提到的shared_ptr循环引用的问题。 接下来简单的分析shared_ptr和weak_ptr的实现,最后通过自己写代码来模拟shared_ptr和weak_ptr,达到深入学习的目的: 测试代码如下: #include "stdafx.h" #include <memory> int _tmain(int argc, _TCHAR* ar

esjiang的博客 239

如何解决智能指针的内存泄漏

为了解决循环引用导致的内存泄漏,引入了weak_ptr弱指针,weak_ptr的构造函数不会修改引用计数的值,从而不会对对象的内存进行管理,其类似一个普通指针,但不指向引用计数的共享内存,但是其可以检测到所管理的对象是否已经被释放,从而避免非法访问。 ...

学无止尽,谨言慎行! 1342

AI 问数真的能替代 BI 报表吗?

AI问数赋能自然语言查询,提升临时分析效率,但无法替代传统报表。报表适用于稳定输出与持续监控,AI则擅长探索性提问。企业用好AI问数,关键在于夯实数据模型、统一指标口径、健全权限体系与结果校验机制。合理组合报表、仪表板与AI,才能实现高效、准确的业务洞察。

葡萄城技术团队博客 341
上一篇: 第 1 周复盘:立项冲动退去后的真实工程量与心智进化
下一篇: 异步上下文中的 Send 与 Sync 约束:多线程调度的编译期安全契约
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值