老生常谈Java虚拟机垃圾回收机制(必看篇)

时间 2019-11-06

标签老生常谈 java 虚拟机垃圾回收机制栏目 Java 繁體版

原文原文链接

2、垃圾收集

垃圾收集主要是针对堆和方法区进行。算法

程序计数器、虚拟机栈和本地方法栈这三个区域属于线程私有的，只存在于线程的生命周期内，线程结束以后也会消失，所以不须要对这三个区域进行垃圾回收。多线程

判断一个对象是否可被回收并发

1. 引用计数算法

给对象添加一个引用计数器，当对象增长一个引用时计数器加 1，引用失效时计数器减 1。引用计数为 0 的对象可被回收。框架

两个对象出现循环引用的状况下，此时引用计数器永远不为 0，致使没法对它们进行回收。函数

正由于循环引用的存在，所以 Java 虚拟机不使用引用计数算法。性能

public class ReferenceCountingGC {

    public Object instance = null;

    public static void main(String[] args) {
        ReferenceCountingGC objectA = new ReferenceCountingGC();
        ReferenceCountingGC objectB = new ReferenceCountingGC();
        objectA.instance = objectB;
        objectB.instance = objectA;
    }
}

2. 可达性分析算法

经过 GC Roots 做为起始点进行搜索，可以到达到的对象都是存活的，不可达的对象可被回收。测试

Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC Roots 通常包含如下内容：spa

虚拟机栈中局部变量表中引用的对象
本地方法栈中 JNI 中引用的对象
方法区中类静态属性引用的对象
方法区中的常量引用的对象

3. 方法区的回收

由于方法区主要存放永久代对象，而永久代对象的回收率比新生代低不少，所以在方法区上进行回收性价比不高。线程

主要是对常量池的回收和对类的卸载。翻译

在大量使用反射、动态代理、CGLib 等 ByteCode 框架、动态生成 JSP 以及 OSGi 这类频繁自定义 ClassLoader 的场景都须要虚拟机具有类卸载功能，以保证不会出现内存溢出。

类的卸载条件不少，须要知足如下三个条件，而且知足了也不必定会被卸载：

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

能够经过 -Xnoclassgc 参数来控制是否对类进行卸载。

4. finalize()

finalize() 相似 C++ 的析构函数，用来作关闭外部资源等工做。可是 try-finally 等方式能够作的更好，而且该方法运行代价高昂，不肯定性大，没法保证各个对象的调用顺序，所以最好不要使用。

当一个对象可被回收时，若是须要执行该对象的 finalize() 方法，那么就有可能在该方法中让对象从新被引用，从而实现自救。 自救只能进行一次，若是回收的对象以前调用了 finalize() 方法自救，后面回收时不会调用 finalize() 方法。

引用类型

不管是经过引用计算算法判断对象的引用数量，仍是经过可达性分析算法判断对象是否可达，断定对象是否可被回收都与引用有关。

Java 提供了四种强度不一样的引用类型。

1. 强引用

被强引用关联的对象不会被回收。

使用 new 一个新对象的方式来建立强引用。

Object obj = new Object();

2. 软引用

被软引用关联的对象只有在内存不够的状况下才会被回收。

使用 SoftReference 类来建立软引用。

Object obj = new Object();
SoftReference<Object> sf = new SoftReference<Object>(obj);
obj = null;  // 使对象只被软引用关联

3. 弱引用

被弱引用关联的对象必定会被回收，也就是说它只能存活到下一次垃圾回收发生以前。

使用 WeakReference 类来实现弱引用。

Object obj = new Object();
WeakReference<Object> wf = new WeakReference<Object>(obj);
obj = null;

4. 虚引用

又称为幽灵引用或者幻影引用。一个对象是否有虚引用的存在，彻底不会对其生存时间构成影响，也没法经过虚引用取得一个对象。

为一个对象设置虚引用关联的惟一目的就是能在这个对象被回收时收到一个系统通知。

使用 PhantomReference 来实现虚引用。

Object obj = new Object();
PhantomReference<Object> pf = new PhantomReference<Object>(obj);
obj = null;

垃圾收集算法

1. 标记 - 清除

将存活的对象进行标记，而后清理掉未被标记的对象。

不足：

标记和清除过程效率都不高；
会产生大量不连续的内存碎片，致使没法给大对象分配内存。

2. 标记 - 整理

让全部存活的对象都向一端移动，而后直接清理掉端边界之外的内存。

3. 复制

将内存划分为大小相等的两块，每次只使用其中一块，当这一块内存用完了就将还存活的对象复制到另外一块上面，而后再把使用过的内存空间进行一次清理。

主要不足是只使用了内存的一半。

如今的商业虚拟机都采用这种收集算法来回收新生代，可是并非将新生代划分为大小相等的两块，而是分为一块较大的 Eden 空间和两块较小的 Survivor 空间，每次使用 Eden 空间和其中一块 Survivor。在回收时，将 Eden 和 Survivor 中还存活着的对象一次性复制到另外一块 Survivor 空间上，最后清理 Eden 和使用过的那一块 Survivor。

HotSpot 虚拟机的 Eden 和 Survivor 的大小比例默认为 8:1，保证了内存的利用率达到 90%。若是每次回收有多于 10% 的对象存活，那么一块 Survivor 空间就不够用了，此时须要依赖于老年代进行分配担保，也就是借用老年代的空间存储放不下的对象。

4. 分代收集

如今的商业虚拟机采用分代收集算法，它根据对象存活周期将内存划分为几块，不一样块采用适当的收集算法。

通常将堆分为新生代和老年代。

新生代使用：复制算法
老年代使用：标记 - 清除或者标记 - 整理算法

垃圾收集器

以上是 HotSpot 虚拟机中的 7 个垃圾收集器，连线表示垃圾收集器能够配合使用。

单线程与多线程：单线程指的是垃圾收集器只使用一个线程进行收集，而多线程使用多个线程；
串行与并行：串行指的是垃圾收集器与用户程序交替执行，这意味着在执行垃圾收集的时候须要停顿用户程序；并行指的是垃圾收集器和用户程序同时执行。除了CMS 和 G1以外，其它垃圾收集器都是以串行的方式执行。

1. Serial 收集器

Serial 翻译为串行，也就是说它以串行的方式执行。

它是单线程的收集器，只会使用一个线程进行垃圾收集工做。

它的优势是简单高效，对于单个 CPU 环境来讲，因为没有线程交互的开销，所以拥有最高的单线程收集效率。

它是 Client 模式下的默认新生代收集器，由于在该应用场景下，分配给虚拟机管理的内存通常来讲不会很大。Serial 收集器收集几十兆甚至一两百兆的新生代停顿时间能够控制在一百多毫秒之内，只要不是太频繁，这点停顿是能够接受的。

2. ParNew 收集器

它是 Serial 收集器的多线程版本。

是 Server 模式下的虚拟机首选新生代收集器，除了性能缘由外，主要是由于除了 Serial 收集器，只有它能与 CMS 收集器配合工做。

默认开启的线程数量与 CPU 数量相同，可使用 -XX:ParallelGCThreads 参数来设置线程数。

3. Parallel Scavenge 收集器

与 ParNew 同样是多线程收集器。

其它收集器关注点是尽量缩短垃圾收集时用户线程的停顿时间，而它的目标是达到一个可控制的吞吐量，它被称为“吞吐量优先”收集器。这里的吞吐量指 CPU 用于运行用户代码的时间占总时间的比值。

停顿时间越短就越适合须要与用户交互的程序，良好的响应速度能提高用户体验。而高吞吐量则能够高效率地利用 CPU 时间，尽快完成程序的运算任务，适合在后台运算而不须要太多交互的任务。

缩短停顿时间是以牺牲吞吐量和新生代空间来换取的：新生代空间变小，垃圾回收变得频繁，致使吞吐量降低。

能够经过一个开关参数打开 GC 自适应的调节策略（GC Ergonomics），就不须要手工指定新生代的大小（-Xmn）、Eden 和 Survivor 区的比例、晋升老年代对象年龄等细节参数了。虚拟机会根据当前系统的运行状况收集性能监控信息，动态调整这些参数以提供最合适的停顿时间或者最大的吞吐量。自适应调节策略是 Parallel Scavenge 收集器和 ParNew 收集器的一个重要区别。

4. Serial Old 收集器

是 Serial 收集器的老年代版本，也是给 Client 模式下的虚拟机使用，采用标记-整理算法。若是用在 Server 模式下，它有两大用途：

在 JDK 1.5 以及以前版本（Parallel Old 诞生之前）中与 Parallel Scavenge 收集器搭配使用。
做为 CMS 收集器的后备预案，在并发收集发生 Concurrent Mode Failure 时使用。

5. Parallel Old 收集器

是 Parallel Scavenge 收集器的老年代版本，采用标记-整理算法。

在注重吞吐量以及 CPU 资源敏感的场合，均可以优先考虑 Parallel Scavenge 加 Parallel Old 收集器。

6. CMS 收集器

CMS（Concurrent Mark Sweep），Mark Sweep 指的是标记 - 清除算法。

分为如下四个流程：

初始标记：仅仅只是标记一下 GC Roots 能直接关联到的对象，速度很快，须要停顿。
并发标记：进行 GC Roots Tracing 的过程，它在整个回收过程当中耗时最长，不须要停顿。
从新标记：为了修正并发标记期间因用户程序继续运做而致使标记产生变更的那一部分对象的标记记录，须要停顿。
并发清除：不须要停顿。

在整个过程当中耗时最长的并发标记和并发清除过程当中，收集器线程均可以与用户线程一块儿工做，不须要进行停顿，具备并发收集、低停顿的优势。

具备如下缺点：

吞吐量低：低停顿时间是以牺牲吞吐量为代价的，致使 CPU 利用率不够高。
没法处理浮动垃圾，可能出现 Concurrent Mode Failure。浮动垃圾是指并发清除阶段因为用户线程继续运行而产生的垃圾，这部分垃圾只能到下一次 GC 时才能进行回收。因为浮动垃圾的存在，所以须要预留出一部份内存，意味着 CMS 收集不能像其它收集器那样等待老年代快满的时候再回收。若是预留的内存不够存放浮动垃圾，就会出现 Concurrent Mode Failure，这时虚拟机将临时启用 Serial Old 来替代 CMS。
标记 - 清除算法致使的空间碎片，每每出现老年代空间剩余，但没法找到足够大连续空间来分配当前对象，不得不提早触发一次 Full GC。

CMS 已经在 JDK 9 中被标记为废弃（ deprecated ）。

7. G1 收集器

G1（Garbage-First），它是一款面向服务端应用的垃圾收集器，在多 CPU 和大内存的场景下有很好的性能。HotSpot 开发团队赋予它的使命是将来能够替换掉 CMS 收集器。

堆被分为新生代和老年代，其它收集器进行收集的范围都是整个新生代或者老年代，而 G1 能够直接对新生代和老年代一块儿回收。

G1 把堆划分红多个大小相等的独立区域（Region），Region的大小是一致的，数值是在1M到32M字节之间的一个2的幂值数，JVM会尽可能划分2048个左右、同等大小的Region，新生代和老年代再也不物理隔离。

经过引入 Region 的概念，从而将原来的一整块内存空间划分红多个的小空间，使得每一个小空间能够单独进行垃圾回收。这种划分方法带来了很大的灵活性，使得可预测的停顿时间模型成为可能。经过记录每一个 Region 垃圾回收时间以及回收所得到的空间（这两个值是经过过去回收的经验得到），并维护一个优先列表，每次根据容许的收集时间，优先回收价值最大的 Region。

每一个 Region 都有一个 Remembered Set，用来记录该 Region 对象的引用对象所在的 Region。经过使用 Remembered Set，在作可达性分析的时候就能够避免全堆扫描。

若是不计算维护 Remembered Set 的操做，G1 收集器的运做大体可划分为如下几个步骤：

初始标记
并发标记
最终标记：为了修正在并发标记期间因用户程序继续运做而致使标记产生变更的那一部分标记记录，虚拟机将这段时间对象变化记录在线程的 Remembered Set Logs 里面，最终标记阶段须要把 Remembered Set Logs 的数据合并到 Remembered Set 中。这阶段须要停顿线程，可是可并行执行。
筛选回收：首先对各个 Region 中的回收价值和成本进行排序，根据用户所指望的 GC 停顿时间来制定回收计划。此阶段其实也能够作到与用户程序一块儿并发执行，可是由于只回收一部分 Region，时间是用户可控制的，并且停顿用户线程将大幅度提升收集效率。

从 GC 算法的角度， G1 选择的是复合算法，能够简化理解为：

在新生代，G1采用的仍然是并行的复制算法，因此一样会发生Stop-The-World的暂停。
在老年代，大部分状况下都是并发标记，而整理（Compact）则是和新生代GC时捎带进行，而且不是总体性的整理，而是增量进行的。

具有以下特色：

空间整合：总体来看是基于“标记 - 整理”算法实现的收集器，从局部（两个 Region 之间）上来看是基于“复制”算法实现的，这意味着运行期间不会产生内存空间碎片。
可预测的停顿：能让使用者明确指定在一个长度为 M 毫秒的时间片断内，消耗在 GC 上的时间不得超过 N 毫秒。

目前尚处于开发中的 JDK 11， JDK 又增长了两种全新的 GC 方式，分别是：

Epsilon GC，简单说就是个不作垃圾收集的GC，彷佛有点奇怪，有的状况下，例如在进行性能测试的时候，可能须要明确判断GC自己产生了多大的开销，这就是其典型应用场景。

ZGC，这是Oracle开源出来的一个超级GC实现，具有使人惊讶的扩展能力，好比支持T bytes级别的堆大小，而且保证绝大部分状况下，延迟都不会超过10 ms。虽然目前还处于实验阶段，仅支持 Linux 64 位的平台，但其已经表现出的能力和潜力都很是使人期待。