十五-垃圾回收相关算法

15.1 标记阶段：引用计数算法

引用计数算法(Reference Counting)比较简单，对每个对象保存一个整型的引用计数器属性，用于记录对象被引用的情况

对于一个对象A，只要有任何一个对象引用了A，则A的引用计数器就加1；当引用失效时，引用计数器就减1.只要对象A的引用计数器的值为0，则表示对象A不可能再被使用，可进行回收

优点：实现简单，便于辨识；判定效率高，没有延迟性
缺点：需要单独的字段存储计数器，增加了存储空间的开销
每次赋值都需要更新计数器，增加了时间开销
无法处理循环引用的情况，这是致命的缺陷，导致在Java的垃圾回收器中没有使用这类算法

测试Java中是否采用的是引用计数算法

public class RefCountGC {
	//证明java使用的不是引用计数算法
    // 这个成员属性的唯一作用就是占用一点内存
    private byte[] bigSize = new byte[5*1024*1024];
    // 引用
    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;
        // 显示的执行垃圾收集行为，判断obj1 和 obj2是否被回收？
        System.gc();
    }
}

小结

Python是同时支持引用计数和垃圾回收机制
Python如何解决循环引用？

• 手动解除：在合适的时机，解除引用关系
• 使用弱引用weakref，weakref是python提供的标准库，解决循环引用

15.2 标记阶段：可达性分析算法

可达性分析算法（根搜索算法、追踪性垃圾收集Tracing Garbage Collection），不仅同样具备实现简单和执行高效的特点，还有效地解决在引用计数算法中循环引用地问题，防止内存泄漏地发生。

基本思路

• 可达性分析算法是以根对象集合(GC Roots 一组必须活跃的引用)为起始点，按照从上到下的方式搜索被根对象集合所连接的目标对象是否可达
• 内存中存活的对象都会被根对象集合直接或间接连接着，搜索所走过的路径称为引用链(Reference Chain)
• 如果目标对象没有任何引用链，则是不可达，意味着该对象已死亡，可标记为垃圾对象
• 只有能够被根对象集合直接或间接连接的对象才是存活对象

GC Roots可以是哪类元素？

• 虚拟机栈中引用的对象，比如：各个线程被调用的方法中使用到的参数、局部变量等
• 本地方法栈内JNI（本地方法）引用的对象
• 方法区中类静态属性引用的对象，比如：Java类的引用类型静态变量
• 方法区中常量引用的都西昂，比如：字符串常量池(StringTable)里的引用
• 所有被同步锁synchronized持有的对象
• Java虚拟机内部的引用，基本数据类型对应的class对象，一些常驻的异常对象，如NullPointerException、OutOfMemoryError，系统类加载器
• 反映java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等
• 除了这些固定的GC Roots外，根据用户所选用的垃圾回收器及当前回收的内存区域不同，还可以有其他对象“临时性”加入，共同构成完整GC Roots集合，比如：分代收集和局部回收(Partial GC)

总结
由于Root采用栈方式存放变量和指针，所以如果一个指针，他保存了堆内存里面的对象，但是自己又不存放在堆内存里面，那他就是一个Root
如果要使用可达性分析算法来判断内存是否可回收，那分析工作必须在能保证一致性的快照中进行，这点不满足分析结果就饿无法保证，这也是导致GC进行时必须"Stop The World"的一个重要原因，即使是号称不会发生停顿的CMS收集器中，枚举根节点也必须要停顿的

15.3 对象的finalization机制

• Java语言提供了对象终止(finalization)机制来允许开发人员提供对象销毁之前的自定义处理逻辑
• 当垃圾回收器发现没有引用指向一个对象，即垃圾回收此对象前，总会先调用这个对象的finalize()方法
• finalize()方法允许在子类中被重写，用于在对象被回收时进行资源释放。通常在这个方法中进行一些资源释放和清理的工作，比如关闭文件、套接字和数据库连接等

对象的finaliztion机制

• 永远不要主动调用某个对象的finazlize()方法，应该交给垃圾回收机制调用。在finalize()时可能会导致对象复活，finalize()方法的执行时间是没有保障的，糟糕的finalize()会严重影响GC性能
• 从功能上说，finalize()方法与C++中的析构函数比较相似，但Java采用的是基于垃圾回收器的自动内存管理机制，所以finalize()在本质上不同于析构函数
• 由于finalize()的存在，虚拟机中的对象一般处于三种可能的状态

生存还是死亡？

三种状态：

• 可触及的：从根节点开始，可以到达该对象
• 可复活的：对象的所有引用都被释放，但对象有可能在finalize()中复活
• 不可触及的：对象的finalize()调用，没有复活，那么就会进入不可触及状态。不可触及的对象不可能被复活，因为finalize()只会被调用一次

具体过程

判定一个对象objA是否可回收，至少要经过两次标记过程：

1. 如果对象objA到GC Roots没有引用链，则进行第一次标记
2. 进行筛选，判断此独享是否有必要执行finalize()方法
   1.如果对象objA没有重新finallize()方法，或finalize()已经被调用过，则虚拟机视为“没有必要执行”，objA被判定为不可触及的
   2.如果对象objA重新了finalize()方法，且未执行过，那么objA会被插入F-Queue队列中，有一个虚拟机自动创建、低优先级的Finalizer线程触发其finalize()方法执行
   3.finalize()方法是对象逃脱死亡的最后机会，稍后GC会堆F-Queue队列中的对象进行第二次标记。如果objA在finalize()方法中与引用链上的任何一个对象建立了联系，那么在第二次标记时，objA会被移出”即将回收“集合。之后，对象会再次出现没有引用存在的情况，在这个情况下，finalize方法不会被再次调用，对象会直接变成不可触及的状态

public class CanReliveObj {
	//测试Object类中finalize()方法
    // 类变量，属于GC Roots的一部分
    public static CanReliveObj canReliveObj;

	//该方法只能调用一次
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("调用当前类重写的finalize()方法");
        canReliveObj = this;//当前待回收的对象与obj建立了联系
    }

    public static void main(String[] args) throws InterruptedException {
        canReliveObj = new CanReliveObj();
        canReliveObj = null;
        System.gc();//调用垃圾回收器
        System.out.println("-----------------第一次gc操作------------");
        // 因为Finalizer线程的优先级比较低，暂停2秒，以等待它
        Thread.sleep(2000);
        if (canReliveObj == null) {
            System.out.println("obj is dead");
        } else {
            System.out.println("obj is still alive");
        }

        System.out.println("-----------------第二次gc操作------------");
        canReliveObj = null;
        System.gc();
        // 下面代码和上面代码是一样的，但是 canReliveObj却自救失败了
        Thread.sleep(2000);
        if (canReliveObj == null) {
            System.out.println("obj is dead");
        } else {
            System.out.println("obj is still alive");
        }
        /*
        *第一次gc alive
        *第二次gc dead
        */
    }
}

15.4 MAT与JProfiler的GC Roots溯源

MAT时Memory Analyzer Tool的简称，是一款功能强大的Java堆内存分析器，用于查找内存泄漏以及查看内存消耗情况。基于Eclipse开发，下载网站http://www.eclipse.org/mat/

获取dump文件

方式1：命令行使用jmap

方式2：使用JVisualVM导出

• 捕获的heap dump文件是一个临时文件，关闭JVisualVM后自动删除，若要保留，需要将其另存为文件
• 可以通过以下方式获取heap dump：
• 左侧”Application“子窗口中点击相应的应用程序，选择Heap Dump。
• 在Monitor子标签页中点击Heap Dump

使用MAT打开dump

实际开发中，一般不会查找全部的GC Roots，可能只是查找某个对象的整个链路，称为GC Roots溯源，可以使用JProfiler

判断什么原因造成OOM

public class HeapOOM {
	/*
	*内存溢出排查
 	* -Xms8m -Xmx8m -XX:HeapDumpOnOutOfMemoryError
	*/
    // 创建1M的文件
    byte [] buffer = new byte[1 * 1024 * 1024];

    public static void main(String[] args) {
        ArrayList<HeapOOM> list = new ArrayList<>();
        int count = 0;
        try {
            while (true) {
                list.add(new HeapOOM());
                count++;
            }
        } catch (Exception e) {
            e.getStackTrace();
            System.out.println("count:" + count);
        }
    }
}

通过线程，可以定位到哪里出现OOM

15.5 清除阶段：标记-清除算法(Mark-Sweep)

执行过程

当堆中的有效内存空间(available memory)被耗尽的时候，就会停止整个程序(stop the world)，然后进行两项工作，第一是标记，第二是清除

• 标记：Collerctor从引用根节点开始遍历，标记所有被引用的对象。一般是在对象的Header中记录为可达对象
• 清除：Collerctor对堆内存从头到尾进行线性的遍历，如果发现某个对象在其Header中没有标记为可达对象，则将其回收

何为清除
这里的清除并不是真的置空，而是把需要清除的对象地址保存在空闲的地址列表里。下次有新对象需要加载时，判断垃圾的位置空间是否够，如果够，就存放

缺点

• 效率不算高
• 在进行GC时，需要停止整个应用程序，导致用户体验差
• 清除出来的空闲内存是不连续的，产生内存碎片。需要一个空闲列表

15.6 清除阶段：复制算法(Copying)

执行过程

为了解决标记-清除算法的缺陷，将活着的内存空间分为两块，每个只使用其中一块，在垃圾回收时将正在使用的内存中的存活对象复制到未被使用的内存块中，之后清除正在使用的内存块中的所有对象，交换两个内存的角色，最后完成垃圾回收。

把可达的对象，直接复制到另一个区域中复制完成后，A区就没有作用了里面的对象直接清除掉，其实里面的新生代里面就用到了复制算法

优点

• 没有标记和清除过程，实现简单，运行高效
• 复制过去保证空间连续性，不会出现碎片问题

缺点

• 需要两倍的内存空间
• 对于G1这种分拆成为大量region的GC，复制而不是移动，意味着GC需要维护region之间对象引用关系，不管是内存占用或时间开销也不小
• 如果系统中的垃圾对象很多，复制算法不会很理想，需要复制的存活对象数量并不会太大或者说非常低才行

应用场景

在新生代，堆常规应用的垃圾回收，一次通常可以回收70-99％的内存空间，回收性价比很高，所以现在的商业虚拟机都是用这种收集算法回收新生代

15.7 清除阶段：标记-压缩（整理）算法(Mark-Compact)

执行过程

第一阶段和标记-清除算法一样，从根节点开始标记所有被引用对象

第二阶段将所有的存活对象压缩到内存的一段，按顺序排放

之后，清理边界外所有的空间

标记-压缩算法的最终效果等同于标记-清除算法执行完成后，再进行一次内存碎片整理，因此也可以称为标记-清除-压缩(Mark-Sweep-Compact)算法
两者的本质差异在于标记-清除算法是一种非移动式的回收算法，标记-压缩是移动式的。是否移动回收后的存活对象是一项优缺点并存的风险决策
标记的存活对象将会被整理，按照内存地址依次排列，未被标记的内存就会被清理。给新对象分配内存时，JVM只需要持有一个内存的起始地址即可，比维护一个空闲列表显然少了很多开销

优点

• 消除了标记-清除算法，内存区域分散的缺点
• 消除了复制算法，内存减半的高额代价

缺点

• 从效率来说，标记-整理算法低于复制算法
• 移动对象的同时，如果对象被其他对象引用，需要调整引用的地址
• 移动过程中，需要STW

15.8 小结

	Mark-Sweep	Mark-Compact	Copying
速度	中等	最慢	最快
空间开销	少，但会堆积碎片	少，不堆积碎片	通常需要活对象的2倍大小，不堆积碎片
移动对象	否	是	是

效率上，复制算法当之无愧的老大，但浪费太多内存

标记-整理算法相对更平滑一些，但效率上不尽人意，比复制算法多了一个标记的阶段，比标记-清除多了一个整理内存的阶段

15.9 分代收集算法

前面所有算法中，并没有一种算法可以完全替代其他算法，都有自己的优势和特点，分代收集算法应运而生

不同对象的生命周期是不一样的，不同生命周期的对象可以采用不同的收集方式，以便提高回收效率，一般是把Java堆分为新生代和老年代，可以根据不同的特点使用不同的回收算法，提高回收效率

目前几乎所有的GC都是采用分代收集(Generational Collecting)算法执行垃圾回收的

在HotSpot中，基于分代的概念，GC所使用的内存回收算法必须结合年轻代和老年代各自的特点

年轻代(Young Gen)

• 特点：区域相对老年代较小，对象生命周期短，存活率低，回收频繁
• 这种情况，复制算法的回收整理，速度是最快的。复制算法的效率只和当前存活对象大小有关，因此很适用于年轻代的回收，而复制算法内存利用率不高的问题，通过HotSpot中的两个survivor的设计得到缓解
  老年代(Tenured Gen)
• 特点：区域较大，对象生命周期长，存活率高，回收不及年轻代频繁
• 存在大量存活率高的对象，复制算法明显不合适。一般是由标记-清除或标签-整理的混合实现
• Mark阶段的开销与存活对象的数量成正相关
• Sweep阶段的开销与所管理区域的大小成正相关
• Compcat阶段的开销与存活对象的数据成正比

以HotSpot中的CMS回收器为例，CMS是基于Mark-Sweep实现的，对于对象的回收效率很高。而对于碎片问题，CMS采用基于Mark-Compact算法的Serial Old回收器作为补偿措施：当内存回收不加（碎片导致的Concurrent Mode Failure时），将采用Serial Old执行Full GC以达到对老年代内存的整理

15.10 增量收集算法、分区算法

上述现有的算法，在垃圾回收过程中，应用软件会处于一种STW的状态。如果垃圾回收时间过长，会严重影响系统稳定性。为了解决这个问题，对实时垃圾收集算法的研究直接导致了增量收集(Incremental Collecting)算法的诞生

基本思想

可以让垃圾收集线程和应用程序线程交替执行。每次，垃圾收集线程只收集一小片区域的内存空间，接着切换到应用程序线程。直到垃圾收集完成

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

缺点

间接性地执行了应用程序代码，所以能减少系统地停顿时间。但是，因为线程切换和上下文转换的消耗，会使垃圾回收的总体成本上升，造成系统吞吐量的下降

分代算法按照对象的生命周期划分为两部分，分区算法将整个堆空间划分成连续的不同小区间region，每一个小区都独立使用，独立回收，可以控制一次回收多少个小区间