九、JVM从入门到精通之垃圾回收机制（算法篇）

前言

垃圾收集，不是Java语言的伴生产物。早在1960年，第一门开始使用内存动态分配和垃圾收集技术的Lisp语言诞生。

关于垃圾收集有三个经典问题：

• 哪些内存需要回收？
• 什么时候回收、
• 如何回收？

垃圾收集机制是Java的招牌能力，极大地提高了开发效率。如今，垃圾收集几乎称为现代语言的标配，即使经过如此长的时间发展，Java的垃圾收集机制仍然在不断的演进中，不同大小的设备、不同特征的应用场景，对垃圾收集提出了新的挑战，这当然也是面试的热点。

垃圾回收热点面试题

蚂蚁金服：

• 你知道哪几种垃圾回收器，各自的优缺点，重点讲一下cms和g1
• JVM GC算法有哪些，目前的JDK版本采用什么回收算法
• G1回收器讲下回收过程？GC是什么？为什么要有GC？

百度：

• 说一下GC算法，分代回收说下
• 垃圾收集策略和算法

阿里：

• Java的垃圾回收器都有哪些，说下g1的应用场景，平时你是如何搭配使用垃圾回收器的
• 什么情况下会触发垃圾回收？
• 如何选择合适的垃圾收集算法
• system.gc（）和runtime.gc()会做什么事情？
• CMS回收停顿了几次，为什么要停顿这几次？

一、什么是JVM垃圾

1.1 什么是垃圾（Garbage)呢？

• 垃圾是指在运行程序中没有任何指针指向的对象，这个对象就是需要被回收的垃圾

• 如果不及时对内存中的垃圾进行清理，那么，这些垃圾对象所占的内存空间会一直保留到应用程序结束，被保留的空间无法被其他对象使用，甚至可能导致内存溢出。

1.2 为什么需要GC？

• 对于高级语言来说，一个基本认知是如果不进行垃圾回收，内存迟早都会被消耗完，因为不断地分配内存空间而不进行回收，就好像不停地生产生活垃圾而从来不打扫一样。
• 除了释放没用的对象，垃圾回收也可以清除内存里的记录碎片，碎片整理将所占用的内存移到堆的一端，以便JVM将整理出的内存分配给新的对象。
• 随着应用程序所应付的业务越来越大、复杂，用户越来越多，没有GC就不能保证应用程序的正常进行。而经常造成STW的GC又跟不上实际需求，所以才会不断地尝试对GC进行优化。

1.3 垃圾回收的发展过程

在早期的C/C++时代，垃圾回收基本上是手工进行的。开发人员可以使用new关键字进行内存申请，并使用delete关键字进行内存释放。比如以下代码：

MibBridge *pBridge =new cmBaseGroupBridge();
//如果注册失败，使用Delete释放该对象所占内存区域
if(pBridge ->Register(kDestroy)!= No_Error)
delete pBridge;

这种方式可以灵活控制内存释放的时间，但是会给开发人员带来频繁申请和释放内存管理负担。倘若有一处内存区间由于程序员编码的问题忘记被回收，那么就会产生内存泄漏，垃圾对象永远无法被清除，随着系统运行时间的不断增长，垃圾对象所耗内存可能持续上升，直到出现内存溢出并造成应用程序崩溃。

• 在有了垃圾回收机制后，上述代码块极有可能变成这样：

MibBridge * pBridge=new cmBaseGroupBridge();
pBridge-。Register(KDestroy);

现在，除了Java以外，C#、Python、Ruby等语言都使用了自动垃圾回收的思想，也是未来发展趋势。可以说，这种自动化的内存分配和垃圾回收的方式已经成为现代开发语言必备的标准。

1.4 垃圾回收机制

• 自动内存管理，无需开发人员手动参与内存的分配与回收，这样降低内存泄漏和内存溢出的风险
  – 没有垃圾回收器，java也会和cpp一样，各种悬挂指针，野指针，泄漏问题让你头疼不已。

• 自动内存管理机制，将程序员从繁重的内存管理中释放出来，可以更专心地专注与业务开发

1.5 垃圾自动回收的问题

• 对于Java开发人员而言，自动内存管理就像一个黑匣子，如果过度依赖于”自动“，那么将会是一场灾难，最严重的就会弱化Java开发人员在程序出现内存溢出时定位问题和解决问题的能力。
• 此时，了解JVM的自动化内存分配和内存回收原理就显得非常重要，只有在真正了解JVM是如何管理内存后，我们才能够在遇见OutOfMemoryError时，快速地根据错误异常日志定位问题和解决问题。
• 当需要排查各种内存溢出、内存泄露问题时，当垃圾收集称为系统达到更高并发量的瓶颈时，我们就必须对这些”自动化“的技术实施必要的监控和调节。

1.6 垃圾回收的区域

• 垃圾回收器可以对年轻代回收，也可以对老年代回收，甚至是全堆和方法区的回收。
  》 其中，Java堆是垃圾回收器的工作重点。

• 从次数上讲
  》频繁收集Young区
  》较少收集Old区
  》基本不懂Perm区

二、垃圾回收相关算法

2.1 垃圾标记阶段：对象存活判断

• 在堆里存放着几乎所有的Java对象实例，在GC执行垃圾回收之前，首先要区分出内存中哪些是存活对象，哪些是已经死亡的对象。只有被标记为已经死亡的对象，GC才会在执行垃圾回收时，释放掉其所占用的内存空间，因此这个过程我们可以称为垃圾标记阶段。
• 那么在JVM中究竟是如何标记一个死亡对象呢？简单来说，当一个对象已经不再被任何的存货对象继续引用时，就可以宣判为已经死亡了。
• 判断对象存活一般有两种方式：引用计数法和可达性分析算法

2.1.1 引用计数算法

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

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

• 优点：实现简单，垃圾对象便于辨识；判定效率高，回收没有延迟性。

• 缺点：
  》他需要单独的字段存储计数器，这样的做法增加了存储空间的开销。
  》每次赋值都需要 更新计数器，伴随着加法和减法操作，这增加了时间开销。
  》引用计数器有一个严重的问题，即无法处理循环引用的情况。这是一条致命缺陷，导致在Java的垃圾回收器中没有使用这类算法。最终会造成内存泄漏

• 引用计数算法，是很多语言的资源回收选择，例如因人工智能而更加火热的Python，它更是同时支持引用计数器和垃圾收集机制。
• 具体那种最优是要看场景的，业界有大规模实践中仅保留引用计数机制，以提高吞吐量的尝试。
• java并没有选择引用计数，是因为其存在一个基本的难题，也就是很难处理循环引用关系。
• Python如何解决循环引用？
  》手动解除：很好理解，就是在合适的时机，解除引用关系。
  》使用弱引用weakref，weakref是python提供的标准库，旨在解决循环引用。

2.1.2 可达性分析（或根搜索算法、追踪醒垃圾收集）

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

所谓"GC Roots"根集合就是一组必须活跃的引用。

基本思路：
》 可达性分析算法是以根对象集合（GC Roots)为起始点，按照从上至下的方式搜索被根对象集合所连接的目标对象是否可达。
》 使用可达性分析算法后，内存中的存货对象都会被根对象集合直接或间接连接着，搜索所走过的路径称为引用链
》 如果目标对象没有任何引用链相连，则是不可达的，就意味着该对象已经死亡，可以标记为垃圾对象。
》 在可达性分析算法中，只有能够被根对象集合直接或者间接链接的对象才是存活对象。

GC Roots包含一下几类元素

• 虚拟机栈中引用的对象

• 本地方法栈内引用的对象

• 方法区中类静态属性引用的对象

• 方法区中常量引用的对象
  比如：字符串常量池（String Table)中的引用

• 所有被同步锁synchronized持有的对象

• Java虚拟机内部的引用
  基本数据类型对象对应的Class对象，一些常驻的异常对象（如：NullpointerException、OutOfMemmoryError)，系统类加载器

• 反映java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等。

注意

• 如果要使用可达性分析短发来判断内存是或否可回收，那么分析工作必须在一个能保障一致性的快照中进行。这点不满足的话分析结果的准确性就无法保证。
• 这点也是导致GC进行时必须“Stop The World”的一个重要原因。

2.1.3 使用JProfiler查看GC Roots

如果程序出现了OOM异常，我们可以使用JProfiler工具分析器来查看程序出问题的地方。

1、先写一段测试代码块

package com.JProfiler_Use;

import java.util.ArrayList;

/**
 *-Xms8m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=d:/aaa.hprof
 */
public class TEST01 {
   byte[] buffer= new byte[1*1024*1024];

    public static void main(String[] args) {
        ArrayList<Object> arrayList = new ArrayList<>();
        int count=0;
        for (int i = 0; i < 100; i++) {
            arrayList.add(new TEST01());
            System.out.println(count);
        }

    }
}

-Xms8m:设置堆的最小内存为8M
-Xmx8m：设置堆的最大内存为8M
-XX:+HeapDumpOnOutOfMemoryError: 设置如果程序发生OOM异常时，生成dump文件
-XX:HeapDumpPath=d:/aaa.hprof：指定dump生成的文件路径及文件名

2、运行程序，使用JProfiler观察异常的详细情况

3、找到生成的dump文件，使用JProfiler打开

也可以通过JProfiler找到程序异常的代码块，也就是代码的第15行

2.2 垃圾清除阶段

当成功区分出内存中存活对象和死亡对象后，GC接下来的任务就是执行垃圾回收，释放掉无用对象所占用的内存空间，以便有足够的可用内存空间为新对象分配内存。

目前在JVM中比较常见的三种垃圾收集算法是 标记-清除算法（Mark-Sweep)、复制算法（Copying)、标记-压缩算法（Mark-Compact）

2.2.1 标记-清除（Mark-Sweep)算法

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

执行过程：
当堆中的有效内存空间（acailable memory)被耗尽的时候就会停止整个程序（也被称为stop the world),然后进行两项工作，第一项则是标记，第二项则是清除。

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

注意：
被标记的对象是能被根节点连接到的对象，而非要被回收的对象

缺点：

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

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

2.2.2 复制算法（Copying)

背景:
为了解决标记-清除算法在垃圾收集效率方面的缺陷，M.L.Minsky于1963年发表了著名的论文，“使用双存储区的Lisp语言垃圾收集器CaLISP Garbage Collector Algorithm Using Serial Secondary Storage)”.M.L.Minsky在该论文中描述的算法被人们称为复制算法。

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

使用案例
新生代和幸存者区发生垃圾回收时，s0、s1之间的复制方式就是采用的复制（Copying）算法。

优点

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

缺点

• 此算法的缺点也是很明显的，就是需要两倍的空间
• 对于G1这种分拆称为大量region（区域）的GC，复制而不是移动，意味着GC需要维护region之间对象引用关系，不管是内存占用或者时间开销也不小。

特别的:

只有系统中的垃圾很多的时候，复制算法相应的效率才会很高，当垃圾比较少的时候，很多存活的对象都要进行复制，效率相应就会很低。正是基于这个原因，新生代中的对象也是朝生夕死，频繁的发生创建和销毁 就非常适合采用复制（Copying)算法。

2.2.3 标记-压缩（或标记-整理）算法

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

标记-清除算法的确可以应用在老年代中，但是该算法不仅执行效率低下，而且在执行完内存回收后还会产生碎片，所以JVM的设计者需要在此基础上进行改进。标记-压缩（Mark-Compact）算法由此诞生。

在许多现代的垃圾收集器中，人们都使用了标记-压缩算法或其改进版本。

执行过程：

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

第二阶段将所有的存活对象压缩到内存的一端，按顺序排放
之后，清理边界外所有的空间。

标记-压缩算法的最终效果等同于标记-清除算法执行完成后，再进行一次内存碎片整理，因此，也可以把它称为标记-清除-压缩算法。
二者的本质差异在于标记-清除算法是一种非移动式的回收算法，标记-压缩是移动式的。是否移动回收后的存活对象是一项优缺点并存的风险决策。

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

优点:

• 消除了标记-清除算法当中，内存区域分散的缺点，我们需要给新对象分配内存时，JVM只需要持有一个内存的起始地址即可。
• 消除了复制算法当中，内存减半的高额代价。

缺点

• 从效率上来说，标记-整理算法要低于复制算法。
• 移动对象的同时，如果对象被其他对象引用，则还需要调整引用的地址。
• 移动过程中，需要全程暂停用户应用程序。即：STW

2.2.4 三种收集算法的对比

效率上来说，复制算法是当之无愧的老大，但是却浪费了太多的内存。
而为了尽量兼顾上面提到的三个指标，标记-整理算法相对来说更平滑一些，但是效率上不尽如意，它比复制算法多了一个标记的阶段，比标记-清除多了一个整理内存的阶段。

2.3 分代收集算法

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

分代收集算法，是基于这样一个事实：不同的对象生命周期是不一样的。因此，不同生命周期的对象可以采取不同的收集方式以便提高回收效率。一般是把Java堆分为新生代和老年代，这样就可以根据各个年代的特点使用不同的回收算法，以提高垃圾回收的效率。

在Java程序运行的过程中，会产生大量的对象，其中有些对象是与业务信息相关，比如Http请求中的Session对象、线程、Socket连接，这类对象跟业务直接挂钩，因此生命周期比较长。但是还有一些对象，主要是程序运行过程中生成的临时变量，这些对象生命周期会比较短，比如：String对象，由于其不变类的特性，系统会产生大量的这些对象，这些对象甚至只用一次即可回收。

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

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

• 年轻代
  年轻代特点：区域相对老年代较小，对象生命周期短、存活率低，回收频繁。

这种情况复制算法的回收整理，速度是最快的，复制算法的效率只和当前存活对象大小有关，因此很适用于年轻代的回收，而复制算法内存利用率不高的问题，通过hotSpot中两个survivor的设计得到缓解。

• 老年代
  老年代特点：区域较大，对生命周期长，存活率高，回收不及年轻代频繁。
  这种情况存在大量存活率高的对象复制算法明显变得不合适。一般是由标记-清除或者是标记-清除与标记-整理的混合实现。
  》》 Mark阶段的开销与存活对象的数量成正比
  》》 Sweep阶段的开销与所管理区域的大小成正相关
  》》 Compact阶段的开销与存活对象的数据成正比

以HotSpot中的CMS回收器为例，CMS是基于Mark-Sweep实现的，对于对象的回收效率很高。而对于碎片问题，CMS采用基于Mark-Compact算法的Serial Old回收器作为补偿措施：当内存回收不佳（碎片导致的Concurrent Mode Failuer时），将采用Serial Old执行Full GC以达到对老年代内存的整理。
分代的思想被现有的虚拟机广泛使用，几乎所有的垃圾 回收器都区分新生代和老年代。

2.4 增量收集算法

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

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

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

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

2.5 分区算法

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

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

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

💥推荐阅读💥

上一篇：八、JVM从入门到精通之String Table(字符串常量池)分析

下一篇：十、JVM从入门到精通之垃圾回收机制（概念篇）