【搞定Jvm面试】 JVM 垃圾回收揭秘附常见面试题解析

JVM 垃圾回收

写在前面

本节常见面试题

问题答案在文中都有提到

• 如何判断对象是否死亡（两种方法）。
• 简单的介绍一下强引用、软引用、弱引用、虚引用（虚引用与软引用和弱引用的区别、使用软引用能带来的好处）。
• 如何判断一个常量是废弃常量
• 如何判断一个类是无用的类
• 垃圾收集有哪些算法，各自的特色？
• HotSpot 为何要分为新生代和老年代？
• 常见的垃圾回收器有那些？
• 介绍一下 CMS,G1 收集器。
• Minor Gc 和 Full GC 有什么不一样呢？

本文导火索

当须要排查各类内存溢出问题、当垃圾收集成为系统达到更高并发的瓶颈时，咱们就须要对这些“自动化”的技术实施必要的监控和调节。

1 揭开 JVM 内存分配与回收的神秘面纱

Java 的自动内存管理主要是针对对象内存的回收和对象内存的分配。同时，Java 自动内存管理最核心的功能是 堆 内存中对象的分配与回收。

Java 堆是垃圾收集器管理的主要区域，所以也被称做GC 堆（Garbage Collected Heap）.从垃圾回收的角度，因为如今收集器基本都采用分代垃圾收集算法，因此 Java 堆还能够细分为：新生代和老年代：再细致一点有：Eden 空间、From Survivor、To Survivor 空间等。进一步划分的目的是更好地回收内存，或者更快地分配内存。

堆空间的基本结构：

<div align="center">
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3堆结构.png" width="400px"/>
</div>

上图所示的 eden 区、s0("From") 区、s1("To") 区都属于新生代，tentired 区属于老年代。大部分状况，对象都会首先在 Eden 区域分配，在一次新生代垃圾回收后，若是对象还存活，则会进入 s1("To")，而且对象的年龄还会加 1(Eden 区->Survivor 区后对象的初始年龄变为 1)，当它的年龄增长到必定程度（默认为 15 岁），就会被晋升到老年代中。对象晋升到老年代的年龄阈值，能够经过参数 -XX:MaxTenuringThreshold 来设置。通过此次GC后，Eden区和"From"区已经被清空。这个时候，"From"和"To"会交换他们的角色，也就是新的"To"就是上次GC前的“From”，新的"From"就是上次GC前的"To"。无论怎样，都会保证名为To的Survivor区域是空的。Minor GC会一直重复这样的过程，直到“To”区被填满，"To"区被填满以后，会将全部对象移动到年老代中。

1.1 对象优先在 eden 区分配

目前主流的垃圾收集器都会采用分代回收算法，所以须要将堆内存分为新生代和老年代，这样咱们就能够根据各个年代的特色选择合适的垃圾收集算法。

大多数状况下，对象在新生代中 eden 区分配。当 eden 区没有足够空间进行分配时，虚拟机将发起一次 Minor GC.下面咱们来进行实际测试如下。

在测试以前咱们先来看看 Minor GC 和 Full GC 有什么不一样呢？

• 新生代 GC（Minor GC）:指发生新生代的的垃圾收集动做，Minor GC 很是频繁，回收速度通常也比较快。
• 老年代 GC（Major GC/Full GC）:指发生在老年代的 GC，出现了 Major GC 常常会伴随至少一次的 Minor GC（并不是绝对），Major GC 的速度通常会比 Minor GC 的慢 10 倍以上。

测试：

public class GCTest {

    public static void main(String[] args) {
        byte[] allocation1, allocation2;
        allocation1 = new byte[30900*1024];
        //allocation2 = new byte[900*1024];
    }
}

经过如下方式运行：

添加的参数：-XX:+PrintGCDetails

运行结果 (红色字体描述有误，应该是对应于 JDK1.7 的永久代)：

从上图咱们能够看出 eden 区内存几乎已经被分配彻底（即便程序什么也不作，新生代也会使用 2000 多 k 内存）。假如咱们再为 allocation2 分配内存会出现什么状况呢？

allocation2 = new byte[900*1024];

简单解释一下为何会出现这种状况： 由于给 allocation2 分配内存的时候 eden 区内存几乎已经被分配完了，咱们刚刚讲了当 Eden 区没有足够空间进行分配时，虚拟机将发起一次 Minor GC.GC 期间虚拟机又发现 allocation1 没法存入 Survivor 空间，因此只好经过 分配担保机制 把新生代的对象提早转移到老年代中去，老年代上的空间足够存放 allocation1，因此不会出现 Full GC。执行 Minor GC 后，后面分配的对象若是可以存在 eden 区的话，仍是会在 eden 区分配内存。能够执行以下代码验证：

public class GCTest {

    public static void main(String[] args) {
        byte[] allocation1, allocation2,allocation3,allocation4,allocation5;
        allocation1 = new byte[32000*1024];
        allocation2 = new byte[1000*1024];
        allocation3 = new byte[1000*1024];
        allocation4 = new byte[1000*1024];
        allocation5 = new byte[1000*1024];
    }
}

1.2 大对象直接进入老年代

大对象就是须要大量连续内存空间的对象（好比：字符串、数组）。

为何要这样呢？

为了不为大对象分配内存时因为分配担保机制带来的复制而下降效率。

1.3 长期存活的对象将进入老年代

既然虚拟机采用了分代收集的思想来管理内存，那么内存回收时就必须能识别哪些对象应放在新生代，哪些对象应放在老年代中。为了作到这一点，虚拟机给每一个对象一个对象年龄（Age）计数器。

若是对象在 Eden 出生并通过第一次 Minor GC 后仍然可以存活，而且能被 Survivor 容纳的话，将被移动到 Survivor 空间中，并将对象年龄设为 1.对象在 Survivor 中每熬过一次 MinorGC,年龄就增长 1 岁，当它的年龄增长到必定程度（默认为 15 岁），就会被晋升到老年代中。对象晋升到老年代的年龄阈值，能够经过参数 -XX:MaxTenuringThreshold 来设置。

1.4 动态对象年龄断定

为了更好的适应不一样程序的内存状况，虚拟机不是永远要求对象年龄必须达到了某个值才能进入老年代，若是 Survivor 空间中相同年龄全部对象大小的总和大于 Survivor 空间的一半，年龄大于或等于该年龄的对象就能够直接进入老年代，无需达到要求的年龄。

2 对象已经死亡？

堆中几乎放着全部的对象实例，对堆垃圾回收前的第一步就是要判断那些对象已经死亡（即不能再被任何途径使用的对象）。

2.1 引用计数法

给对象中添加一个引用计数器，每当有一个地方引用它，计数器就加 1；当引用失效，计数器就减 1；任什么时候候计数器为 0 的对象就是不可能再被使用的。

这个方法实现简单，效率高，可是目前主流的虚拟机中并无选择这个算法来管理内存，其最主要的缘由是它很难解决对象之间相互循环引用的问题。 所谓对象之间的相互引用问题，以下面代码所示：除了对象 objA 和 objB 相互引用着对方以外，这两个对象之间再无任何引用。可是他们由于互相引用对方，致使它们的引用计数器都不为 0，因而引用计数算法没法通知 GC 回收器回收他们。

public class ReferenceCountingGc {
    Object instance = null;
    public static void main(String[] args) {
        ReferenceCountingGc objA = new ReferenceCountingGc();
        ReferenceCountingGc objB = new ReferenceCountingGc();
        objA.instance = objB;
        objB.instance = objA;
        objA = null;
        objB = null;

    }
}

2.2 可达性分析算法

这个算法的基本思想就是经过一系列的称为 “GC Roots” 的对象做为起点，从这些节点开始向下搜索，节点所走过的路径称为引用链，当一个对象到 GC Roots 没有任何引用链相连的话，则证实此对象是不可用的。

2.3 再谈引用

不管是经过引用计数法判断对象引用数量，仍是经过可达性分析法判断对象的引用链是否可达，断定对象的存活都与“引用”有关。

JDK1.2 以前，Java 中引用的定义很传统：若是 reference 类型的数据存储的数值表明的是另外一块内存的起始地址，就称这块内存表明一个引用。

JDK1.2 之后，Java 对引用的概念进行了扩充，将引用分为强引用、软引用、弱引用、虚引用四种（引用强度逐渐减弱）

1．强引用（StrongReference）

之前咱们使用的大部分引用实际上都是强引用，这是使用最广泛的引用。若是一个对象具备强引用，那就相似于必不可少的生活用品，垃圾回收器毫不会回收它。当内存空间不足，Java 虚拟机宁愿抛出 OutOfMemoryError 错误，使程序异常终止，也不会靠随意回收具备强引用的对象来解决内存不足问题。

2．软引用（SoftReference）

若是一个对象只具备软引用，那就相似于无关紧要的生活用品。若是内存空间足够，垃圾回收器就不会回收它，若是内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就能够被程序使用。软引用可用来实现内存敏感的高速缓存。

软引用能够和一个引用队列（ReferenceQueue）联合使用，若是软引用所引用的对象被垃圾回收，JAVA 虚拟机就会把这个软引用加入到与之关联的引用队列中。

3．弱引用（WeakReference）

若是一个对象只具备弱引用，那就相似于无关紧要的生活用品。弱引用与软引用的区别在于：只具备弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程当中，一旦发现了只具备弱引用的对象，无论当前内存空间足够与否，都会回收它的内存。不过，因为垃圾回收器是一个优先级很低的线程， 所以不必定会很快发现那些只具备弱引用的对象。

弱引用能够和一个引用队列（ReferenceQueue）联合使用，若是弱引用所引用的对象被垃圾回收，Java 虚拟机就会把这个弱引用加入到与之关联的引用队列中。

4．虚引用（PhantomReference）

"虚引用"顾名思义，就是形同虚设，与其余几种引用都不一样，虚引用并不会决定对象的生命周期。若是一个对象仅持有虚引用，那么它就和没有任何引用同样，在任什么时候候均可能被垃圾回收。

虚引用主要用来跟踪对象被垃圾回收的活动。

虚引用与软引用和弱引用的一个区别在于： 虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，若是发现它还有虚引用，就会在回收对象的内存以前，把这个虚引用加入到与之关联的引用队列中。程序能够经过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序若是发现某个虚引用已经被加入到引用队列，那么就能够在所引用的对象的内存被回收以前采起必要的行动。

特别注意，在程序设计中通常不多使用弱引用与虚引用，使用软引用的状况较多，这是由于软引用能够加速 JVM 对垃圾内存的回收速度，能够维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生。

2.4 不可达的对象并不是“非死不可”

即便在可达性分析法中不可达的对象，也并不是是“非死不可”的，这时候它们暂时处于“缓刑阶段”，要真正宣告一个对象死亡，至少要经历两次标记过程；可达性分析法中不可达的对象被第一次标记而且进行一次筛选，筛选的条件是此对象是否有必要执行 finalize 方法。当对象没有覆盖 finalize 方法，或 finalize 方法已经被虚拟机调用过期，虚拟机将这两种状况视为没有必要执行。

被断定为须要执行的对象将会被放在一个队列中进行第二次标记，除非这个对象与引用链上的任何一个对象创建关联，不然就会被真的回收。

2.5 如何判断一个常量是废弃常量

运行时常量池主要回收的是废弃的常量。那么，咱们如何判断一个常量是废弃常量呢？

假如在常量池中存在字符串 "abc"，若是当前没有任何 String 对象引用该字符串常量的话，就说明常量 "abc" 就是废弃常量，若是这时发生内存回收的话并且有必要的话，"abc" 就会被系统清理出常量池。

注意：咱们在 多是把 Java 内存区域讲的最清楚的一篇文章 也讲了 JDK1.7 及以后版本的 JVM 已经将运行时常量池从方法区中移了出来，在 Java 堆（Heap）中开辟了一块区域存放运行时常量池。

2.6 如何判断一个类是无用的类

方法区主要回收的是无用的类，那么如何判断一个类是无用的类的呢？

断定一个常量是不是“废弃常量”比较简单，而要断定一个类是不是“无用的类”的条件则相对苛刻许多。类须要同时知足下面 3 个条件才能算是 “无用的类” ：

• 该类全部的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例。
• 加载该类的 ClassLoader 已经被回收。
• 该类对应的 java.lang.Class 对象没有在任何地方被引用，没法在任何地方经过反射访问该类的方法。

虚拟机能够对知足上述 3 个条件的无用类进行回收，这里说的仅仅是“能够”，而并非和对象同样不使用了就会必然被回收。

3 垃圾收集算法

3.1 标记-清除算法

该算法分为“标记”和“清除”阶段：首先标记出全部须要回收的对象，在标记完成后统一回收全部被标记的对象。它是最基础的收集算法，后续的算法都是对其不足进行改进获得。这种垃圾收集算法会带来两个明显的问题：

1. 效率问题
2. 空间问题（标记清除后会产生大量不连续的碎片）

<img src="http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-8-27/63707281.jpg" alt="公众号" width="500px">

3.2 复制算法

为了解决效率问题，“复制”收集算法出现了。它能够将内存分为大小相同的两块，每次使用其中的一块。当这一块的内存使用完后，就将还存活的对象复制到另外一块去，而后再把使用的空间一次清理掉。这样就使每次的内存回收都是对内存区间的一半进行回收。

<img src="http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-8-27/90984624.jpg" alt="公众号" width="500px">

3.3 标记-整理算法

根据老年代的特色提出的一种标记算法，标记过程仍然与“标记-清除”算法同样，但后续步骤不是直接对可回收对象回收，而是让全部存活的对象向一端移动，而后直接清理掉端边界之外的内存。

3.4 分代收集算法

当前虚拟机的垃圾收集都采用分代收集算法，这种算法没有什么新的思想，只是根据对象存活周期的不一样将内存分为几块。通常将 java 堆分为新生代和老年代，这样咱们就能够根据各个年代的特色选择合适的垃圾收集算法。

好比在新生代中，每次收集都会有大量对象死去，因此能够选择复制算法，只须要付出少许对象的复制成本就能够完成每次垃圾收集。而老年代的对象存活概率是比较高的，并且没有额外的空间对它进行分配担保，因此咱们必须选择“标记-清除”或“标记-整理”算法进行垃圾收集。

延伸面试问题： HotSpot 为何要分为新生代和老年代？

根据上面的对分代收集算法的介绍回答。

4 垃圾收集器

若是说收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。

虽然咱们对各个收集器进行比较，但并不是要挑选出一个最好的收集器。由于直到如今为止尚未最好的垃圾收集器出现，更加没有万能的垃圾收集器，咱们能作的就是根据具体应用场景选择适合本身的垃圾收集器。试想一下：若是有一种四海以内、任何场景下都适用的完美收集器存在，那么咱们的 HotSpot 虚拟机就不会实现那么多不一样的垃圾收集器了。

4.1 Serial 收集器

Serial（串行）收集器收集器是最基本、历史最悠久的垃圾收集器了。你们看名字就知道这个收集器是一个单线程收集器了。它的 “单线程” 的意义不只仅意味着它只会使用一条垃圾收集线程去完成垃圾收集工做，更重要的是它在进行垃圾收集工做的时候必须暂停其余全部的工做线程（ "Stop The World" ），直到它收集结束。

新生代采用复制算法，老年代采用标记-整理算法。

虚拟机的设计者们固然知道 Stop The World 带来的不良用户体验，因此在后续的垃圾收集器设计中停顿时间在不断缩短（仍然还有停顿，寻找最优秀的垃圾收集器的过程仍然在继续）。

可是 Serial 收集器有没有优于其余垃圾收集器的地方呢？固然有，它简单而高效（与其余收集器的单线程相比）。Serial 收集器因为没有线程交互的开销，天然能够得到很高的单线程收集效率。Serial 收集器对于运行在 Client 模式下的虚拟机来讲是个不错的选择。

4.2 ParNew 收集器

ParNew 收集器其实就是 Serial 收集器的多线程版本，除了使用多线程进行垃圾收集外，其他行为（控制参数、收集算法、回收策略等等）和 Serial 收集器彻底同样。

新生代采用复制算法，老年代采用标记-整理算法。

它是许多运行在 Server 模式下的虚拟机的首要选择，除了 Serial 收集器外，只有它能与 CMS 收集器（真正意义上的并发收集器，后面会介绍到）配合工做。

并行和并发概念补充：

• 并行（Parallel） ：指多条垃圾收集线程并行工做，但此时用户线程仍然处于等待状态。
• 并发（Concurrent）：指用户线程与垃圾收集线程同时执行（但不必定是并行，可能会交替执行），用户程序在继续运行，而垃圾收集器运行在另外一个 CPU 上。

4.3 Parallel Scavenge 收集器

Parallel Scavenge 收集器也是使用复制算法的多线程收集器，它看上去几乎和ParNew都同样。 那么它有什么特别之处呢？

-XX:+UseParallelGC 

    使用 Parallel 收集器+ 老年代串行

-XX:+UseParallelOldGC

    使用 Parallel 收集器+ 老年代并行

Parallel Scavenge 收集器关注点是吞吐量（高效率的利用 CPU）。CMS 等垃圾收集器的关注点更多的是用户线程的停顿时间（提升用户体验）。所谓吞吐量就是 CPU 中用于运行用户代码的时间与 CPU 总消耗时间的比值。 Parallel Scavenge 收集器提供了不少参数供用户找到最合适的停顿时间或最大吞吐量，若是对于收集器运做不太了解的话，手工优化存在困难的话能够选择把内存管理优化交给虚拟机去完成也是一个不错的选择。

新生代采用复制算法，老年代采用标记-整理算法。

4.4.Serial Old 收集器

Serial 收集器的老年代版本，它一样是一个单线程收集器。它主要有两大用途：一种用途是在 JDK1.5 以及之前的版本中与 Parallel Scavenge 收集器搭配使用，另外一种用途是做为 CMS 收集器的后备方案。

4.5 Parallel Old 收集器

Parallel Scavenge 收集器的老年代版本。使用多线程和“标记-整理”算法。在注重吞吐量以及 CPU 资源的场合，均可以优先考虑 Parallel Scavenge 收集器和 Parallel Old 收集器。

4.6 CMS 收集器

CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。它很是符合在注重用户体验的应用上使用。

CMS（Concurrent Mark Sweep）收集器是 HotSpot 虚拟机第一款真正意义上的并发收集器，它第一次实现了让垃圾收集线程与用户线程（基本上）同时工做。

从名字中的Mark Sweep这两个词能够看出，CMS 收集器是一种 “标记-清除”算法实现的，它的运做过程相比于前面几种垃圾收集器来讲更加复杂一些。整个过程分为四个步骤：

• 初始标记： 暂停全部的其余线程，并记录下直接与 root 相连的对象，速度很快 ；
• 并发标记： 同时开启 GC 和用户线程，用一个闭包结构去记录可达对象。但在这个阶段结束，这个闭包结构并不能保证包含当前全部的可达对象。由于用户线程可能会不断的更新引用域，因此 GC 线程没法保证可达性分析的实时性。因此这个算法里会跟踪记录这些发生引用更新的地方。
• 从新标记： 从新标记阶段就是为了修正并发标记期间由于用户程序继续运行而致使标记产生变更的那一部分对象的标记记录，这个阶段的停顿时间通常会比初始标记阶段的时间稍长，远远比并发标记阶段时间短
• 并发清除： 开启用户线程，同时 GC 线程开始对为标记的区域作清扫。

从它的名字就能够看出它是一款优秀的垃圾收集器，主要优势：并发收集、低停顿。可是它有下面三个明显的缺点：

• 对 CPU 资源敏感；
• 没法处理浮动垃圾；
• 它使用的回收算法-“标记-清除”算法会致使收集结束时会有大量空间碎片产生。

4.7 G1 收集器

G1 (Garbage-First) 是一款面向服务器的垃圾收集器,主要针对配备多颗处理器及大容量内存的机器. 以极高几率知足 GC 停顿时间要求的同时,还具有高吞吐量性能特征.

被视为 JDK1.7 中 HotSpot 虚拟机的一个重要进化特征。它具有一下特色：

• 并行与并发：G1 能充分利用 CPU、多核环境下的硬件优点，使用多个 CPU（CPU 或者 CPU 核心）来缩短 Stop-The-World 停顿时间。部分其余收集器本来须要停顿 Java 线程执行的 GC 动做，G1 收集器仍然能够经过并发的方式让 java 程序继续执行。
• 分代收集：虽然 G1 能够不须要其余收集器配合就能独立管理整个 GC 堆，可是仍是保留了分代的概念。
• 空间整合：与 CMS 的“标记--清理”算法不一样，G1 从总体来看是基于“标记整理”算法实现的收集器；从局部上来看是基于“复制”算法实现的。
• 可预测的停顿：这是 G1 相对于 CMS 的另外一个大优点，下降停顿时间是 G1 和 CMS 共同的关注点，但 G1 除了追求低停顿外，还能创建可预测的停顿时间模型，能让使用者明确指定在一个长度为 M 毫秒的时间片断内。

G1 收集器的运做大体分为如下几个步骤：

• 初始标记
• 并发标记
• 最终标记
• 筛选回收

G1 收集器在后台维护了一个优先列表，每次根据容许的收集时间，优先选择回收价值最大的 Region(这也就是它的名字 Garbage-First 的由来)。这种使用 Region 划份内存空间以及有优先级的区域回收方式，保证了 GF 收集器在有限时间内能够尽量高的收集效率（把内存化整为零）。

参考

• 《深刻理解 Java 虚拟机：JVM 高级特性与最佳实践（第二版》
• https://my.oschina.net/hosee/...
• https://docs.oracle.com/javas...

开源项目推荐

做者的其余开源项目推荐：

1. JavaGuide：【Java学习+面试指南】 一份涵盖大部分Java程序员所须要掌握的核心知识。
2. springboot-guide : 适合新手入门以及有经验的开发人员查阅的 Spring Boot 教程（业余时间维护中，欢迎一块儿维护）。
3. programmer-advancement : 我以为技术人员应该有的一些好习惯！
4. spring-security-jwt-guide :从零入门 ！Spring Security With JWT（含权限验证）后端部分代码。

公众号