引用计数法的循环引用问题

最新推荐文章于 2025-05-19 21:20:30 发布
原创 最新推荐文章于 2025-05-19 21:20:30 发布 · 1.1w 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

探讨了引用计数法的基本原理，分析了其在处理循环引用时的局限性，并对比了不同垃圾回收策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 

  • 关于引用计数法,我们可以先看一段wiki上的描述:

     

    As a collection algorithm, reference counting tracks, for each object, a count of the number of references to it held by other objects. If an object's reference count reaches zero, the object has become inaccessible, and can be destroyed.

     

    When an object is destroyed, any objects referenced by that object also have their reference counts decreased.

     

    作为一种回收算法,引用计数法记录着每一个对象被其它对象所持有的引用数。如果一个对象的引用计数为零,那么该对象就变成了所谓的不可达对象,亦即可以被回收的。

     

    当一个对象被回收后,被该对象所引用的其它对象的引用计数都应该相应减少。

     

    而所谓的循环引用(circular referrence)有是什么意思呢?举个简单的例子:

     

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

     

    publicclassMyObject {

    publicObject ref =null;

    publicstaticvoidmain(String[] args) {

    MyObject myObject1 =newMyObject();

    MyObject myObject2 =newMyObject();

    myObject1.ref = myObject2;

    myObject2.ref = myObject1;

    myObject1 =null;

    myObject2 =null;

    }

    }

     

    从上面的代码可以轻易地发现myObject1与myObject2互为引用,我们知道如果采用引用计数法,myObject1和myObject2将不能被回收,因为他们的引用计数无法为零。引用计数法的循环引用问题_Java

     

    但是具体是为什么呢?已上图为例,当代码执行完line7时,两个对象的引用计数均为2。此时将myObject1和myObject2分别置为null,以前一个对象为例,它的引用计数将减1。若要满足垃圾回收的条件,需要清除myObject2中的ref这个引用,而要清除掉这个引用的前提条件是myObject2引用的对象被回收,可是该对象的引用计数也为1,因为myObject1.ref指向了它。以此类推,也就进入一种死循环的状态。

    第二篇:

     

    微软将运行在公共语言运行时里的代码成为托管代码;但是从更广泛的意义上来说,只要语言提供了自动内存管理功能,我们使用其开发的代码都可以称为托管代码;自动内存管理即我们平时所说的垃圾回收器,垃圾回收器的实现是一个复杂的过程,其中涉及到很多的细节;垃圾回收器的难点并不是垃圾的回收过程,而是定位垃圾对象。当一个对象不再被引用的时候就可以被回收了,但是我们怎样才能知道其没有被引用呢?

     

    算法定义

     

    为每个对象增加一个字段记录被引用的次数,并由运行时跟踪和更新引用的总数;

     

    object p = new ComparableInt32(57);

     

    object q = p;

     

    我们实例化了一个对象ComparableInt32,并将其赋值给变量p,此时p引用了该对象,所以其计数器为1;然后我们又用p给变量q赋值,此时q也引用了该变量,所以其计数器变为2;如下图所示

     

    引用计数法的循环引用问题_Java

    从上图我们可以看到,引用类型每次赋值都需要运行时更新计数器,运行时的更新代码可能如下

     

    if (p != q)

     

    {

     

    if (p != null)

     

    --p.refCount;

     

    p = q;

     

    if (p != null)

     

    ++p.refCount;

     

    }

    计数器算法的一大优势就是不用等待内存不够用的时候,才进行垃圾的回收,其可以在赋值操作的同时,检查计数器是否为0,如果是的话就可以立即回收;运行时的代码可能如下

     

    if (p != q)

     

    {

     

    if (p != null)

     

    if (--p.refCount == 0)

     

    heap.Release(p);

     

    p = q;

     

    if (p != null)

     

    ++p.refCount;

     

    }

     

    计数器算法的一大缺点就是不能解决循环引用的问题;如下图,我们构造了一个列表,我们将最后一个元素的next属性指向第一个元素,即引用第一个元素,从而构成循环引用;这个时候如果我们将列表的头head赋值为null,此时列表的各个元素的计数器都不为0,同时我们也失去了对列表的引用控制,从而导致列表元素不能被回收!

     

    引用计数法的循环引用问题_Java

    算法特点

     

    1. 需要单独的字段存储计数器,增加了存储空间的开销;

     

    2. 每次赋值都需要更新计数器,增加了时间开销;

     

    3. 垃圾对象便于辨识,只要计数器为0,就可作为垃圾回收;

     

    4. 及时回收垃圾,没有延迟性;

     

    5. 不能解决循环引用的问题;

     

    http://blog.youkuaiyun.com/hou478410969/article/details/7530032

    第三篇:

     

    jvm区域总体分两类,heap区和非heap区。heap区又分:Eden Space(伊甸园)、Survivor Space(幸存者区)、Tenured Gen(老年代-养老区)。 非heap区又分:Code Cache(代码缓存区)、Perm Gen(永久代)、Jvm Stack(Java虚拟机栈)、Local Method Statck(本地方法栈)。

     

    HotSpot虚拟机GC算法采用分代收集算法:

     

    1、一个人(对象)出来(new 出来)后会在Eden Space(伊甸园)无忧无虑的生活,直到GC到来打破了他们平静的生活。GC会逐一问清楚每个对象的情况,有没有钱(此对象的引用)啊,因为GC想赚钱呀,有钱的才可以敲诈嘛。然后富人就会进入Survivor Space(幸存者区),穷人的就直接kill掉。

     

    2、并不是进入Survivor Space(幸存者区)后就保证人身是安全的,但至少可以活段时间。GC会定期(可以自定义)会对这些人进行敲诈,亿万富翁每次都给钱,GC很满意,就让其进入了Genured Gen(养老区)。万元户经不住几次敲诈就没钱了,GC看没有啥价值啦,就直接kill掉了。

     

    3、进入到养老区的人基本就可以保证人身安全啦,但是亿万富豪有的也会挥霍成穷光蛋,只要钱没了,GC还是kill掉。

     

    分区的目的:新生区由于对象产生的比较多并且大都是朝生夕灭的,所以直接采用标记-清理算法。而养老区生命力很强,则采用复制算法,针对不同情况使用不同算法。

     

    非heap区域中Perm Gen中放着类、方法的定义,jvm Stack区域放着方法参数、局域变量等的引用,方法执行顺序按照栈的先入后出方式。

     

    以上转自:http://lhc1986.iteye.com/blog/1421832

     

    以下转自:http://www.cnblogs.com/xhr8334/archive/2011/12/01/2270994.html

     

     


    GC工作机制 

    SUN的jvm内存池被划分为以下几个部分:

     

    Eden Space (heap)

     

    内存最初从这个线程池分配给大部分对象。

    Survivor Space (heap)

     

    用于保存在eden space内存池中经过垃圾回收后没有被回收的对象。

    Tenured Generation (heap)

     

    用于保持已经在survivor space内存池中存在了一段时间的对象。

    Permanent Generation (non-heap)

     

    保存虚拟机自己的静态(reflective)数据,例如类(class)和方法(method)对象。Java虚拟机共享这些类数据。这个区域被分割为只读的和只写的。

    Code Cache (non-heap)

     

    HotSpot Java虚拟机包括一个用于编译和保存本地代码(native code)的内存,叫做“代码缓存区”(code cache)。

    简单来讲,jvm的内存回收过程是这样的:

     

    对象在Eden Space创建,当Eden Space满了的时候,gc就把所有在Eden Space中的对象扫描一次,把所有有效的对象复制到第一个Survivor Space,同时把无效的对象所占用的空间释放。当Eden Space再次变满了的时候,就启动移动程序把Eden Space中有效的对象复制到第二个Survivor Space,同时,也将第一个Survivor Space中的有效对象复制到第二个Survivor Space。如果填充到第二个Survivor Space中的有效对象被第一个Survivor Space或Eden Space中的对象引用,那么这些对象就是长期存在的,此时这些对象将被复制到Permanent Generation。

     

    若垃圾收集器依据这种小幅度的调整收集不能腾出足够的空间,就会运行Full GC,此时jvm gc停止所有在堆中运行的线程并执行清除动作。

  • 以上是引用计数法的循环引用问题的内容，更多 计数法 引用 循环 问题 的内容，请您使用右上方搜索功能获取相关信息。
JVM中引用计数法与可达性分析_引用计数法和可达性分析
2401_86372608的博客
09-07 1150
有些人认为方法区（如HotSpot虚拟机种的元空间或者永久代）是没有垃圾收集行为的，《Java虚拟机规范》中提到过可以不要求虚拟机在方法区中实现垃圾收集，事实上也确实有未实现或未能完整实现方法区类型卸载的收集器存在（如JDK 11时期的ZGC收集器就不支持类卸载），方法区垃圾收集的“性价比”通常也是比较低的：在Java堆中，尤其是在新生代中，对常规应用进行一次垃圾收集通常可以回收70%至99%的内存空间，相比之下，方法区回收囿于苛刻的判定条件，其区域垃圾收集的回收成果往往远低于此。
JVM——堆的回收：引用计数发和可达性分析法、五种对象引用
m0_73864806的博客
02-13 715
软引用中的对象如果在内存不足时回收，SoftReference对象本身也需要被回收。，只要这层关系存在，普通对象就不会被回收，除了强引用外，java中还设计了几种其他引用方式。引用计数法会为每个对象维护一个引用计数器，当对象被引用时加1，取消引用时减1。如果一个对象只有软引用关联到它，当程序内存不足时，就会将软引用中的数据进行回收。弱引用包含的对象在垃圾回收时，不管内存够不够都会直接被回收。可达性算法中描述的对象引用，一般指的是强引用，即是。软引用相对强引用是一种比较软弱的引用关系，
如何解决循环引用问题？
最新发布
weixin_46072507的博客
05-19 436
在Java中，循环引用通常不会导致内存泄漏，因为Java的垃圾回收机制使用可达性分析算法，而非引用计数法。只要对象从GCRoots不可达，即使它们互相引用，也会被回收。然而，如果循环引用链中仍有强引用连接到GCRoots，对象将不会被回收，可能导致内存泄漏。为避免这种情况，可以采取以下措施：及时释放无用引用、使用弱引用结构、避免滥用静态集合，以及使用内存分析工具检测泄漏。总之，Java的GC能有效处理循环引用，但开发者仍需注意避免因强引用导致的内存泄漏。
怎么解决引用计数 GC 的循环引用问题？
鸿蒙开发知识记录
08-07 1087
作者：Android面试官 引用计数方式 GC 存在循环引用问题，导致无法辨别无用对象，而 GC ROOT 方式不存在循环引用的问题 引用计数和 GC ROOT 的实现机理很易理解，面试时大家都能流利应答，那怎么才能脱颖而出呢？思考一个问题：不通过 GC ROOT，仍使用引用计数方式，怎么解决它的循环引用问题？ 解答此问题前，通过目标驱动法来想象一下，若 Get 了此知识点，可以这样应用到面试中： 面试官： 说一下垃圾回收机制吧 我： …可以通过强、弱引用计数结合方式解决引用计数的循环引用问题，实际上
引用计数法如何处理循环引用
DKPT的博客
05-18 520
引用计数法在处理循环引用时存在一些问题。循环引用是指两个或多个对象相互引用，形成一个闭环，导致每个对象的引用计数都不为0，但实际上这些对象可能已经不再需要，应该被垃圾回收。在引用计数法中，由于循环引用的存在，即使对象实际上已经不再使用，它们的引用计数也不会降到0，因此无法被垃圾回收器回收，从而导致内存泄漏。
引用计数器无法解决循环引用的问题。原理是什么？如何解决？
cpy1356140308的博客
05-04 1204
总结起来，引用计数器无法解决循环引用的问题，因为循环引用导致对象的引用计数永远不会变为零。为了解决循环引用，需要使用可达性分析算法，通过判断对象是否与GC Roots可达来决定对象的存活状态，从而解决循环引用导致的问题。在Java中，垃圾回收器使用可达性分析算法，从一组称为"GC Roots"的根对象开始遍历，查找所有可达的对象，并将不可达的对象标记为垃圾，最后将其回收。在上述示例中，如果没有其他引用指向对象A和对象B，即使它们相互引用，它们也会被判定为不可达，从而可以被垃圾回收。
面经复盘系列之「Java GC中使用引用计数法所存在的缺点」问题应该如何去思考
weixin_42907817的博客
08-22 818
网抑云二面面经 网抑云二面虽然难偏怪，但是复盘下来，确实能学到很多。 也感谢很多大佬跟我分享他们学习的思路和思考的方向，才写了这一篇文章，后续的有缘更新吧。 阅读前必看： 如果你只是想知道这个问题的答案，请出门左转找别人的博客，我这里并没有放出答案，而是以「就问题本身该怎么去思考」提供了自己的想法。 那么现在我们回到正题。 Java GC中使用引用计数法所存在的缺点 首先是Javaer人尽皆知的循环依赖，然后呢？ 说实话，面试时因为【突如其来的没有自我介绍就直入主题 和 跳表刚讲了一句就被示意下一题】这种
雨流计数法的matlab实现-三点法与四点法两种实现方法
03-14
雨流计数法，众所周知是对疲劳载荷的一种分析方法，此文档为应用三点法与四点法的雨流计数法的具体matlab代码与部分测试数据（都是随机生成的数据），如果有人能想在此基础上加一个交互界面，那是很感谢，我不太熟...
雨流计数法的三点法matlab实现
03-14
雨流计数法，又称雨流循环计数法（Rainflow Counting Method），是一种在疲劳寿命分析中广泛应用的数据处理技术。这种方法主要用于从随机应力或应变时间历程中提取疲劳相关的信息，比如疲劳寿命预测和损伤累积。三点...
关于引用计数法的循环引用问题
weixin_45207388的博客
03-11 2630
现在JVM大多不采用引用计数法 进行GC，很大程度上是因为引用计数法不能解决循环引用的问题。 如下代码 public class TestClass { private Object ref; public static void main(String[] args) { TestClass o1 = new TestClass(); // 1 ...
如何解决引用计数的循环引用问题
weixin_43958091的博客
03-28 3638
循环引用 public class MyObject { public Object ref = null; public static void main(String[] args) { MyObject myObject1 = new MyObject(); MyObject myObject2 = new MyObject(); ...
引用计数法中循环引用的问题
lzz1098666594的博客
03-15 773
啥是引用计数法 顾名思义，就是当一个对象被引用的时候进行数字计数，当增加一次引用的时候计数+1，当删除一个对象的引用时-1；当一个对象的引用变成0的时候，就可以被回收了 出现的问题 请先看代码： public class Test { public static void main (String args[]){ MyObject1 object1 = new...
内存回收中引用计数算法的循环引用问题
Chuan73的博客
04-24 1512
在阅读西门吹牛和Gityuan的文章之后，总结记录下引用计数算法的循环引用问题。示例代码如下：public static void main(String[] args) { GcObject obj1 = new GcObject(); //Step1 GcObject obj 2 = new GcObject();//Step2 obj1.ins...
java gc 循环引用_怎么解决引用计数 GC 的循环引用问题？
weixin_33238848的博客
02-24 865
作者：Android面试官引用计数方式 GC 存在循环引用问题，导致无法辨别无用对象，而 GC ROOT 方式不存在循环引用的问题引用计数和 GC ROOT 的实现机理很易理解，面试时大家都能流利应答，那怎么才能脱颖而出呢？思考一个问题：不通过 GC ROOT，仍使用引用计数方式，怎么解决它的循环引用问题？解答此问题前，通过目标驱动法来想象一下，若 Get 了此知识点，可以这样应用到面试中：面试官...
垃圾回收-引用计数法循环引用问题
weixin_30855761的博客
07-01 607
　　实现思路：给对象添加一个引用计数器。每当有一个地方引用它时，计数器加1；引用失效时计数器减1。在任何时刻计数器为0的对象就是不可能再被使用的。 　　优点：实现简单，效率高。 　　缺点：很难解决对象之间的相互循环引用。A引用B，B引用A——循环引用（引用计数算法）由于A、B彼此引用对方，导致引用计数都不为0，所以GC无法回收它们 1 public class MyObject {...
自动引用计数与循环引用
专注于苹果IOS开发和最新资讯
07-20 722
自动引用计数和循环引用实例分析
object类 引用计数
04-05
<think>嗯，用户想知道object类、引用计数、垃圾回收和内存管理之间的关系。首先，我需要回忆一下这些概念的基础知识。 Object类应该是面向对象编程中的基类，比如在Python中所有类都继承自object。那引用计数呢，引用计数是一种垃圾回收的算法，通过跟踪对象的引用次数来决定是否回收内存。垃圾回收则是自动管理内存的机制，而内存管理涉及程序如何分配和释放内存。 接下来，我需要确定用户的具体问题。用户提到“object类与引用计数的关系”，可能是在问像Python这样的语言中，object类如何与引用计数机制交互。比如，每个对象实例是否都有一个引用计数器？或者object类的方法是否会影响引用计数？ 然后，结合用户提供的引用资料，特别是引用[2]和[4]，其中提到了引用计数的原理和优缺点。引用计数法在对象不再被引用时立即回收，这可能和object类的生命周期有关。例如，当对象不再被引用时，引用计数降为零，触发回收。 另外，用户可能想知道不同语言中的实现差异，比如Python使用引用计数为主，而Java则使用标记清除等其他GC算法。这时候需要区分不同语言中object类的作用，以及它们如何与各自的垃圾回收机制结合。 还要注意用户可能的实际需求，比如如何避免内存泄漏，或者如何优化内存使用。例如，在Python中，循环引用会导致引用计数无法归零，这时候就需要其他机制如分代回收来处理。 最后，整理这些点，确保回答结构清晰，涵盖object类在内存管理中的角色，引用计数的原理及其在垃圾回收中的应用，以及不同语言中的实现差异。同时，提供相关的问题帮助用户进一步探索。</think>### Object类与引用计数、垃圾回收及内存管理的关系分析 #### 一、Object类在内存管理中的角色 在面向对象编程中，`object`类是所有类的基类（如Python、Java等语言），每个对象实例都包含元数据（如类型信息、引用计数等）。例如在Python中： ```python class MyClass(object): # 显式继承object类 pass ``` 对象实例通过`__dict__`存储属性，并通过内置的引用计数机制跟踪其生命周期[^2]。 #### 二、引用计数与垃圾回收 1. **引用计数原理** 每个对象内置一个计数器，记录指向它的引用数量： - **增加引用**：赋值操作、参数传递时，计数器$+1$ - **减少引用**：变量离开作用域、显式赋值为`None`时，计数器$-1$ - **回收条件**：当计数器$=0$时，对象被立即回收 ```python a = MyClass() # 引用计数=1 b = a # 引用计数=2 del b # 引用计数=1 ``` 2. **引用计数的局限性** - **循环引用问题**：两个对象互相引用时，计数器无法归零 ```python class Node: def __init__(self): self.parent = None self.child = None x = Node() y = Node() x.child = y # x的引用计数=2 y.parent = x # y的引用计数=2 ``` - **解决方案**：Python引入分代回收机制作为补充[^4] #### 三、垃圾回收机制的实现层次 | 机制类型 | 触发条件 | 优点 | 缺点 | |----------------|--------------------------|---------------------------|-----------------------| | 引用计数 | 实时检测 | 即时回收内存 | 无法处理循环引用 | | 标记-清除 | 内存不足时触发 | 解决循环引用问题 | 产生程序暂停(STW) | | 分代回收 | 基于对象存活时间分级管理 | 提升大规模内存回收效率 | 实现复杂度高 | #### 四、不同语言的实现差异 1. **Python** - 主用引用计数，辅以分代回收 - 可通过`gc`模块手动控制回收 - 示例：强制回收循环引用对象 ```python import gc gc.collect() # 显式触发完整回收 ``` 2. **Java** - 完全采用追踪式GC（如G1、ZGC） - `Object`类含`finalize()`方法（已弃用） - 内存泄漏场景： ```java // 未注销监听器导致泄漏 public class LeakDemo { private static List<EventListener> listeners = new ArrayList<>(); void addListener(EventListener l) { listeners.add(l); } } ``` #### 五、优化建议 1. **减少大对象创建频率**（如数据库连接池） 2. **及时断开无用引用**（特别是在事件监听场景） 3. **避免在关键代码路径触发GC**（如游戏渲染循环）
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值