深入理解垃圾回收相关算法

因为热爱所以坚持，因为热爱所以等待。熬过漫长无戏可演的日子，终于换来了人生的春天，共勉！！！

垃圾回收篇之垃圾回收相关算法

前言:

(1). 判断对象存活的两种方式(引用计数算法、枚举根节点做可达性分析) (2). 标记阶段(引用计数法、枚举根节点做可达性分析) (3). 清除阶段(标记复制算法、标记清除算法、标记整理(压缩)算法、分代收集、增量收集算法、分区算法)

1.引用计数算法

①. 原理:假设有一个对象A,任何一个对象对A的引用,那么对象A的引用计数器+1,当引用失败时,对象A的引用计数器就-1,如果 对象A的计数器的值为0 ,就说明对象A没有引用了, 可以被回收

②. 最大的缺陷: 无法解决循环引用的问题 ,gc永远都清除不了(这也是引用计数法被淘汰的原因)

③. 代码展示:

    /**
     * -XX:+PrintGCDetails
     * 证明:java使用的不是引用计数算法
     */
    public class RefCountGC {
        //这个成员属性唯一的作用就是占用一点内存
        private byte[] bigSize = new byte[5 * 1024 * 1024];//5MB
    
        Object reference = null;
    
        public static void main(String[] args) {
            RefCountGC obj1 = new RefCountGC();
            RefCountGC obj2 = new RefCountGC();
    
            obj1.reference = obj2;
            obj2.reference = obj1;
    
            obj1 = null;
            obj2 = null;
            //显式的执行垃圾回收行为
            //这里发生GC,obj1和obj2能否被回收？
            System.gc();
    
            try {
                Thread.sleep(1000000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

④. 注意: Java使用的不是引用计数法 (Java之所以没有使用引用计数法,是由于不能解决循环引用问题) | (Python使用了是引用计数法)

⑤. Python如何解决循环引用( 扩展了解 )

手动解决:很好理解,就是在合适的时机,解除引用关系使用弱引用weakref,weakref是Python提供的标准库,旨在解决循环引用(只要发生了回收,弱引用都会被回收)

2.可达性分析算法(枚举根节点做可达性分析)

①. 基本思路: 通过一系列名为"GC Roots"的对象(集合)作为起点,**从这个被称为GC ROOTs 的对象开始向下搜索,** 如果一个对象到GC Roots没有任何引用链相连时,则说明此对象是不可达对象(被回收),否则就是可达对象

②.在java中,可作为GC Roots的对象有(熟记)

    <code>(1).**虚拟机栈(栈帧中的局部变量表)中的引用对象**(比如各个线程被调用的方法中使用到的参数、
    局部变量等)
    (2).**本地方法栈中JNI(即一般来说native方法)中引用的对象**[ 线程中的start方法 ]
    (3).**静态属性引用的对象**(比如:Java类的引用类型静态变量)
    (4).**方法区中常量引用的对象**(比如:字符串常量池(String Table)里的引用)
    (5).**所有被synchronized持有的对象**
    (6).**Java虚拟机内部的引用**(基本数据类型对应的**Class对象**,一些**常驻的异常对象**
    [如NullPointerException、OutofMemoryError],**系统类加载器**)
    (7).反映java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等
    </code>

③. 关于GCroot对象集合注意事项:

注意: 除了这些固定的GC Roots集合之外, 根据用户所选用的垃圾收集器以及当前回收的内存区域不同 ,还可以有 其他对象临时加入 , 共同构架完成整GC Roots 集合 。比如: 分代收集和局部回收(面试加分项)

解释: 如果只针对java堆中的某一区域进行垃圾回收(比如: 典型的只针对新生代),必须考虑到内存区域是虚拟机自己的实现细节,更不是孤立封闭的,这个区域的对象完全有可能被其他区域的对象所引用时候就需要一并将关联的区域对象也加入到GC Roots 集合中考虑,才能保证可达性分析的准确性

④. 小技巧: 由于Root采用栈方式存放变量和指针,所以如果一个指针,它保存了堆内存里面的对象,但是自己又不存放在堆内存里面,那它就是一个Root

⑤. 优势:

相对于引用计数法而言,可达性分析算法不仅同样具备实现简单和执行高效等特点,更重要的是 该算法可以有效解决在引用计数算法中循环引用的问题,防止内存泄漏的发生 相较于引用计数算法,这里的可达性分析就是Java、C#选择的 。这种类型的垃圾收集通常也叫做 追踪性垃圾收集

⑥. 可达性分析算法的注意事项: 如果要使用可达性分析算法来判断内存是否可回收,那么分析工作必须在 一个能保障一致性的快照中进行 。这点不满足的话分析结果的准确性就无法保证。这点也是导致GC进行时必须“StopTheWorld"的一个重要原因。 (即使是号称(几乎)不会发生停顿的CMS收集器中, 枚举根节点时也是必须要停顿的 )

3.finalization机制

finalization机制说明 ①. finalize( ) 方法允许在子类中被重写,用于对象被回收时进行资源释放。通常在这个方法中进行一些 资源释放和清理的工作,比如关闭文件、套接字和数据库连接等

②. 当垃圾回收器发现没有引用指向一个对象,即:垃圾收集此对象之前,总会先调用这个对象的finalize( )方法

③. Java语言提提供了对象终止(finalization)机制来允许开发人员提供对象被销毁之前的自定义逻辑

④. 不主动调用某个对象的finalize( ) 方法 ,应该交给垃圾回收机制调用,理由包括下面三点

1.在finalize( )时可能会导致对象复活
2.finalize( )方法执行时间是没有保障的,它完全由GC线程决定,极端情况下,若不发生GC,则finalize( ) 方法将没有执行机会
3.一个糟糕的finalize( )会严重影响GC的性能

⑤. 由于finalize( )方法的存在, 虚拟机中的对象 一般处于 三种可能的状态

1.可触及的:从根节点开始,可以到达这个对象
2.可复活的:对象的所有引用都被释放,但是对象有可能在finalize( )中复活
3.不可触及的: 对象的finalize( )被调用,并且没有复活,那么就会进入不可触及状态。不可触及的对象不可能被复活,因为finalize( )只会被调用一次

判断一个对象是否可以进行回收(理解) 以上3种状态中, 是由于finalize()方法的存在,进行的区分 。只有在对象不可触及时才可以被回收。判定是否可以回收具体过程判定一个对象objA是否可回收,至少要经历两次标记过程:

    **
     * 测试Object类中finalize()方法,即对象的finalization机制。
     *
     */
    public class CanReliveObj {
        public static CanReliveObj obj;//类变量,属于 GC Root
    
    
        //此方法只能被调用一次
        @Override
        protected void finalize() throws Throwable {
            super.finalize();
            System.out.println("调用当前类重写的finalize()方法");
            obj = this;//当前待回收的对象在finalize()方法中与引用链上的一个对象obj建立了联系
        }
    
    
        public static void main(String[] args) {
            try {
                obj = new CanReliveObj();
                // 对象第一次成功拯救自己
                obj = null;
                System.gc();//调用垃圾回收器
                System.out.println("第1次 gc");
                // 因为Finalizer线程优先级很低,暂停2秒,以等待它
                Thread.sleep(2000);
                if (obj == null) {
                    System.out.println("obj is dead");
                } else {
                    System.out.println("obj is still alive");
                }
                System.out.println("第2次 gc");
                // 下面这段代码与上面的完全相同,但是这次自救却失败了
                obj = null;
                System.gc();
                // 因为Finalizer线程优先级很低,暂停2秒,以等待它
                Thread.sleep(2000);
                if (obj == null) {
                    System.out.println("obj is dead");
                } else {
                    System.out.println("obj is still alive");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

4.标记清除算法(Mark一Sweep)

①. 标记一清除算法(Mark一Sweep)是一种非常基础和常见的垃圾收集算法,该算法被J . McCarthy等人在1960年提出并并应用于Lisp语言

②. 标记:Collector(垃圾回收器)从 引用根节点开始遍历,标记所有被引用的对象 。一般是在对象的Header中记录为可达对象

③. 清除: Collector(垃圾回收器) 对堆内存从头到尾进行线性的遍历,如果发现某个对象在其Header中没有标记为可达对象,则将其回收

④. 图解: CMS使用这种方式

⑤. 优缺点

优点:不需要额外的空间

缺点:

两次扫描,耗时严重
清理出来的空闲内存不连续,会产生内存碎片,需要维护一个空闲列表
效率比较低:递归与全堆对象遍历两次(经历了两次遍历)

⑥. 注意:这里所谓的 清除并不是真的置空 ,而是 把需要清除的对象地址保存在空闲的地址列表里 。下次有新对象需要加载时,判断垃圾的位置空间是否够, 如果够则用新的对象则覆盖原来的数据

5. 复制算法(Copying)

①. 核心思想:将活着的内存空间分为两块,每次只使用其中一块,在垃圾回收时将正在.使用的内存中的存活对象复制到未被使用的内存块中,之后清除正在使用的内存块中的所有对象,交换两个内存的角色,最后完成垃圾回收。

②. 描述(重点掌握)

③. 优缺点 优点:

没有标记和清除过程,实现简单,运行高效
不会产生内存碎片,且对象完整不丢

缺点:

浪费了10%的空间
对于G1这种分拆成为大量region的GC,复制而不是移动,意味着GC需要维护region之间对象引用关系,不管是内存占用或者时间开销也不小。

注意:复制算法需要复制的 存活对象数量不多或者很少才行 。因为新生代中的对象一般都是朝生夕死的, 在新生代中使用复制算法是非常好的

注意:是当伊甸园区满后, 会触发minjor gc ,进行垃圾的回收

6.标记整理(压缩)算法(Mark-Compact)

①. 背景: 复制算法的高效性是建立在存活对象少、垃圾对象多的前提下的 。这种情况在新生代经常发生,但是在 老年代 ,更常见的情况是 大部分对象都是存活对象 。如果依然使用复制算法,由于存活对象较多,复制的成本也将很高。因此,基于老年代垃圾回收的特性,需要使用其他的算法。

②. 执行过程:

第一阶段和标记一清除算法一样,从根节点开始标记所有被引用对象.
第二阶段将所有的存活对象压缩到内存的一端,按顺序排放。
最后,清理边界外所有的空间。

可以看到, 标记的存活对象将会被整理, 按照内存地址依次排列 , 而未被标记的内存会被清理掉。如此一来,当我们需要给新对象分配内存时,JVM只需要持有一个内存的起始地址即可,这比维护一个空闲列表显然少了许多开销

③. 图解:

④. 指针碰撞 (如果内存空间以规整和有序的方式分布,即 已用和未用的内存都各自一边 ,彼此之间维系着一个记录 下一次分配起始点的标记指针 ,当为新对象分配内存时,只需要通过 修改指针的偏移量 将新对象分配在 第一个空闲内存位置上 ,这种分配方式就叫做 指针碰撞 (Bump the Pointer))

⑤. 优缺点

优点: ①. 消除了 标记一清除算法当中, 内存区域分散的缺点 ,我们需要给新对象分配内存时,JVM只需要持有一个 内存的起始地址 即可

②. 消除了复制算法当中,内存减半的高额代价

缺点: ①. 从效率.上来说,标记一整理算法要低于复制算法。

②. 移动对象的同时,如果对象被其他对象引用,则还需要调整引用的地址。移动过程中,需要全程暂停用户应用程序。即: STW

7.分代收集算法

写在最前面: ( 分代算法是针对对象的不同特征,而使用合适的算法,这里面 并没有实际上的新算法产生 。与其说分代搜集算法是第五个算法,不如说它是对前三个算法的实际应用, 在 新生代使用复制算法eden占8分空间,survivor占两个1分,只浪费10%的空闲空间 。 老年代使用标记清除/标记压缩算法清除 )

①. 没有最好的算法,只有更合适的算法

②. 新生代(Young Gen)

新生代特点:

区域相对老年代较小,对象生命周期短、存活率低,回收频繁。
这种情况复制算法的回收整理,速度是最快的。复制算法的效率只和当前存活对象大小有关,因此很适用于年轻代的回收。而复制算法内存利用率不高的问题,通过hotspot中的两个survivor的设计得到缓解

④. 老年代(Tenured Gen) 老年代特点:

区域较大,对象生命周期长、存活率高,回收不及年轻代频繁。
这种情况存在大量存活率高的对象,复制算法明显变得不合适。 一般是由标记一清除或者是标记一清除与标记一整理的混合实现 。

- 标记(Mark)阶段的开销与存活对象的数量成正比 - 清除(Sweep)阶段的开销与所管理区域的大小成正相关 - 整理(Compact)阶段的开销与存活对象的数据成正比

8.增量收集算法(了解)

①. 上述现有的算法,在垃圾回收过程中,应用软件将处于一种 stop the World 的状态。在Stop the World状态下, 应用程序所有的线程都会挂起 , 暂停一切正常的工作,等待垃圾回收的完成 。如果垃圾回收时间过长, 应用程序会被挂起很久,将严重影响用户体验或者系统的稳定性 。为了解决这个问题,即对实时垃圾收集算法的研究直接导致了 增量收集(Incremental Collecting) 算法 的诞生

②. 基本思想(理解)

如果 一次性 将所有的垃圾进行处理,需要造成系统长时间的停顿,那么就可以让 垃圾收集线程 和 应用程序线程交替执行 。每次,垃圾收集线程只 收集一小片区域的内存空间 ,接着切换到应用程序线程。依次反复,直到垃圾收集完成

总的来说,增量收集算法的基础仍是传统的标记一清除和复制算法。 增量收集算法通过对线程间冲突的妥善处理,允许垃圾收集线程以分阶段的方式完成标记、清理或复制工作。

③. 缺点: (使用这种方式,由于在垃圾回收过程中,间断性地还执行了应用程序代码,所以能减少系统的停顿时间。但是, 因为线程切换和上下文转换的消耗 , 会使得垃圾回收的总体成本上升 ,造成系统吞吐量的下降。)

9.分区算法(了解)

①. 一般来说,在相同条件下,堆空间越大,一次GC时所需要的时间就越长,有关GC产生的停顿也越长。为了更好地控制GC产生的停顿时间,将一块大的内存区域 分割成多个小块 ,根据目标的停顿时间, 每次合理地回收若干个小区间 , 而不是整个堆空间 ,从而 减少一次GC所产生的停顿。

②. 分代算法 将按照对象的生命周期长短划分成 两个部分 , 分区算法 将整个堆空间划分成 连续的不同小区间

③. 每一个小区间都独立使用,独立回收 。这种算法的好处是可以控制一次回收多少个小区间。