JVM_12 垃圾回收3-垃圾回收器

时间 2020-07-06

标签 jvm 垃圾回收栏目 Java 繁體版

原文原文链接

完整JVM学习笔记请戳

GC的分类与性能指标

垃圾收集器没有在规范中进行过多的规定，能够由不一样的厂商、不一样版本的JVM来实现。
因为JDK的版本处于高速迭代过程当中，所以Java发展至今已经衍生了众多的GC版本。
从不一样角度分析垃圾收集器，能够将GC分为不一样的类型。

按线程数分，能够分为串行垃圾回收器和并行垃圾回收器html

串行回收指的是在同一时间段内只容许有一个CPU用于执行垃圾回收操做，此时工做线程被暂停，直至垃圾收集工做结束。
- ➢在诸如单CPU处理器或者较小的应用内存等硬件平台不是特别优越的场合，串行回收器的性能表现能够超过并行回收器和并发回收器。因此，串行回收默认被应用在客户端的Client模式下的JVM中
- ➢在并发能力比较强的CPU上，并行回收器产生的停顿时间要短于串行回收器。
和串行回收相反，并行收集能够运用多个CPU同时执行垃圾回收，所以提高了应用的吞吐量，不过并行回收仍然与串行回收同样，采用独占式，使用了“ Stop一the一world”机制。

按照工做模式分，能够分为并发式垃圾回收器和独占式垃圾回收器java

并发式垃圾回收器与应用程序线程交替工做，以尽量减小应用程序的停顿时间。
独占式垃圾回收器（Stop the world）一旦运行，就中止应用程序中的全部用户线程，直到垃圾回收过程彻底结束。

按碎片处理方式分，可分为压缩式垃圾回收器和非压缩式垃圾回收器git

压缩式垃圾回收器会在回收完成后，对存活对象进行压缩整理，消除回收后的碎片。
- 再分配对象空间使用: 指针碰撞
非压缩式的垃圾回收器不进行这步操做。
- 再分配对象空间使用: 空闲列表

按工做的内存区间分，又可分为年轻代垃圾回收器和老年代垃圾回收器github

评估GC的性能指标

==吞吐量：运行用户代码的时间占总运行时间的比例==web
- （总运行时间：程序的运行时间十内存回收的时间）
垃圾收集开销：吞吐量的补数，垃圾收集所用时间与总运行时间的比例。面试
==暂停时间：执行垃圾收集时，程序的工做线程被暂停的时间==算法
收集频率：相对于应用程序的执行，收集操做发生的频率。windows
==内存占用： Java堆区所占的内存大小==bash
快速：一个对象从诞生到被回收所经历的时间。服务器
这三者共同构成一个“不可能三角”。三者整体的表现会随着技术进步而愈来愈好。一款优秀的收集器一般最多同时知足其中的两项。
这三项里，暂停时间的重要性日益凸显。由于随着硬件发展，内存占用多些愈来愈能容忍，硬件性能的提高也有助于下降收集器运行时对应用程序的影响，即提升了吞吐量。而内存的扩大，对延迟反而带来负面效果。
简单来讲，主要抓住两点：
- 吞吐量
- 暂停时间

吞吐量

吞吐量就是CPU用于运行用户代码的时间与CPU总消耗时间的比值，即吞吐量=运行用户代码时间/ （运行用户代码时间+垃圾收集时间）
- ➢好比：虚拟机总共运行了100分钟，其中垃圾收集花掉1分钟，那吞吐量就是99%
这种状况下，应用程序能容忍较高的暂停时间，所以，高吞吐量的应用程序有更长的时间基准，快速响应是没必要考虑的。
吞吐量优先，意味着在单位时间内，STW的时间最短： 0.2 + 0.2 = 0.4

暂停时间

“暂停时间”是指一个时间段内应用程序线程暂停，让GC线程执行的状态
- ➢例如，GC期间100毫秒的暂停时间意味着在这100毫秒期间内没有应用程序线程是活动的。.
暂停时间优先，意味着尽量让单次STW的时间最短： 0.1 + 0.1 + 0.1 + 0.1+0.1=0.5

高吞吐量较好由于这会让应用程序的最终用户感受只有应用程序线程在作“生产性”工做。直觉上，吞吐量越高程序运行越快。
低暂停时间（低延迟）较好由于从最终用户的角度来看无论是GC仍是其余缘由致使一个应用被挂起始终是很差的。这取决于应用程序的类型，有时候甚至短暂的200毫秒暂停均可能打断终端用户体验。所以，具备低的较大暂停时间是很是重要的，特别是对于一一个交互式应用程序。
不幸的是”高吞吐量”和”低暂停时间”是一对相互竞争的目标（矛盾）。
- ➢由于若是选择以吞吐量优先，那么必然须要下降内存回收的执行频率，可是这样会致使GC须要更长的暂停时间来执行内存回收。
- ➢相反的，若是选择以低延迟优先为原则，那么为了下降每次执行内存回收时的暂停时间，也只能频繁地执行内存回收，但这又引发了年轻代内存的缩诚和致使程序吞吐量的降低。
在设计（或使用） GC算法时，咱们必须肯定咱们的目标：一个GC算法只可能针对两个目标之一（即只专一于较大吞吐量或最小暂停时间），或.尝试找到一个两者的折衷。
如今标准：在最大吞吐量优先的状况下，下降停顿时间。

不一样的垃圾回收器概述

垃圾收集机制是Java的招牌能力，极大地提升了开发效率。这固然也是面试的热点。
那么，Java常见的垃圾收集器有哪些？

垃圾收集器发展史

有了虚拟机，就必定须要收集垃圾的机制，这就是Garbage Collection，对应的产品咱们称为Garbage Collector.

1999年随JDK1.3.1一起来的是串行方式的Serial GC，它是第一款GC。ParNew垃圾收集器是Serial收集器的多线程版本
2002年2月26日，Parallel GC和Concurrent Mark Sweep GC跟随JDK1.4.2一块儿发布
Parallel GC在JDK6以后成为HotSpot默认GC。
2012年，在JDK1.7u4版本中，G1可用。
2017年，JDK9中G1变成默认的垃圾收集器，以替代CMS。
2018年3月，JDK10中G1垃圾回收器的并行完整垃圾回收，实现并行性来改善最坏状况下的延迟。
==------------分水岭------------==
2018年9月，JDK11发布。引入Epsilon垃圾回收器，又被称为"No一0p （无操做） "回收器。同时，引入ZGC：可伸缩的低延迟垃圾回收器（Experimental）。
2019年3月，JDK12发布。加强G1，自动返回未用堆内存给操做系统。同时，引入Shenandoah GC：低停顿时间的GC （Experimental）。
2019年9月，JDK13发布。加强ZGC，自动返回未用堆内存给操做系统。
2020年3月，JDK14发布。删除CMS垃圾回收器。扩展ZGC在macOS和Windows.上的应用

7款经典的垃圾收集器

串行回收器：Serial. Serial Old
并行回收器：ParNew. Parallel Scavenge. Parallel Old
并发回收器：CMS. G1

7款经典的垃圾收集器与垃圾分代之间的关系

新生代收集器： Serial、 ParNeW、Parallel Scavenge；
老年代收集器： Serial 0ld、 Parallel 0ld、 CMS；
整堆收集器： G1；

垃圾收集器的组合关系

两个收集器间有连线，代表它们能够搭配使用： Serial/Serial 01d、Serial/CMS、 ParNew/Serial 01d、ParNew/CMS、 Parallel Scavenge/Serial 01d、Parallel Scavenge/Parallel 0ld、G1；
其中Serial 0ld做为CMS 出现"Concurrent Mode Failure"失败的后备预案。 3.（红色虚线）因为维护和兼容性测试的成本，在JDK 8时将Serial+CMS、 ParNew+Serial 01d这两个组合声明为废弃（JEP 173），并在JDK 9中彻底取消了这些组合的支持（JEP214），即：移除。
（绿色虚线）JDK 14中：弃用Parallel Scavenge和Serial0ld GC组合（JEP366 ）
（青色虚线）JDK 14中：删除CMS垃圾回收器（JEP 363）

为何要有不少收集器个不够吗？由于Java的使用场景不少，移动端，服务器等。因此就须要针对不一样的场景，提供不一样的垃圾收集器，提升垃圾收集的性能。
虽然咱们会对各个收集器进行比较，但并不是为了挑选一个最好的收集器出来。没有一种放之四海皆准、任何场景下都适用的完美收集器存在，更加没有万能的收集器。因此咱们选择的只是对具体应用最合适的收集器。

查看默认的垃圾收集器

一xx：+PrintCommandLineFlags：查看命令行相关参数（包含使用的垃圾收集器）
使用命令行指令： jinfo 一flag相关垃圾回收器参数进程ID

/**
 *  -XX:+PrintCommandLineFlags
 *
 *  -XX:+UseSerialGC:代表新生代使用Serial GC ，同时老年代使用Serial Old GC
 *
 *  -XX:+UseParNewGC：标明新生代使用ParNew GC
 *
 *  -XX:+UseParallelGC:代表新生代使用Parallel GC
 *  -XX:+UseParallelOldGC : 代表老年代使用 Parallel Old GC
 *  说明：两者能够相互激活
 *
 *  -XX:+UseConcMarkSweepGC：代表老年代使用CMS GC。同时，年轻代会触发对ParNew 的使用
 */
public class GCUseTest {
    public static void main(String[] args) {
        ArrayList<byte[]> list = new ArrayList<>();

        while(true){
            byte[] arr = new byte[100];
            list.add(arr);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

复制代码

输出

-XX:InitialHeapSize=268435456 -XX:MaxHeapSize=4294967296 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseParallelGC 
复制代码

或命令行
jdk8 使用的是parallel

jdk9 使用的是G1

Serial回收器:串行回收

Serial收集器是最基本、历史最悠久的垃圾收集器了。JDK1.3以前回收新生代惟一的选择。
Serial收集器做为HotSpot中Client模式下的默认新生代垃圾收集器。
Serial收集器采用复制算法、串行回收和"Stop一 the一World"机制的方式执行内存回收。）
除了年轻代以外，Serial收集器还提供用于执行老年代垃圾收集的Serial 0ld收集器。 Serial 0ld收集器一样也采用了串行回收和"Stop the World"机制，只不过内存回收算法使用的是标记一压缩算法。
- ➢Serial 0ld是运行在Client模式下默认的老年代的垃圾回收器
- ➢Serial 0ld在Server模式下主要有两个用途：①与新生代的ParallelScavenge配合使用; ②做为老年代CMS收集器的后备垃圾收集方案
这个收集器是一个单线程的收集器，但它的“单线程”的意义并不只仅说明它只会使用一个CPU或一条收集线程去完成垃圾收集工做，更重要的是在它进行垃圾收集时，必须暂停其余全部的工做线程，直到它收集结束（Stop The World ）。

优点

简单而高效（与其余收集器的单线程比），对于限定单个CPU的环境来讲，Seria1收集器因为没有线程交互的开销，专心作垃圾收集天然能够得到最高的单线程收集效率。
- ➢运行在Client模式下的虛拟机是个不错的选择。
在用户的桌面应用场景中，可用内存通常不大（几十MB至一两百MB），能够在较短期内完成垃圾收集（几十ms至一百多ms），只要不频繁发生，使用串行回收器是能够接受的。
在HotSpot虛拟机中，使用一XX： +UseSerialGC 参数能够指定年轻代和老年代都使用串行收集器。
- 等价于新生代用Serial GC，且老年代用Serial 0ld GC
- 控制台输出 -XX:InitialHeapSize=268435456 -XX:MaxHeapSize=4294967296 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseSerialGC

总结

这种垃圾收集器你们了解，如今已经不用串行的了。并且在限定单核cpu才能够用。如今都不是单核的了。
对于交互较强的应用而言，这种垃圾收集器是不能接受的。T通常在Javaweb应用程序中是不会采用串行垃圾收集器的。

ParNew回收器:并行回收

若是说Serial GC是年轻代中的单线程垃圾收集器，那么ParNew收集器则是Serial收集器的多线程版本。
- ➢Par是Paralle1的缩写，New：只能处理的是新生代
ParNew收集器除了采用并行回收的方式执行内存回收外，两款垃圾收集器之间几乎没有任何区别。ParNew收集器在年轻代中一样也是采用复制算法、"Stop一 the一World"机制。
ParNew是不少JVM运行在Server模式下新生代的默认垃圾收集器。
对于新生代，回收次数频繁，使用并行方式高效。
对于老年代，回收次数少，使用串行方式节省资源。（CPU并行须要切换线程，串行能够省去切换线程的资源）
因为ParNew收集器是基于并行回收，那么是否能够判定ParNew收集器的回收效率在任何场景下都会比Serial收集器更高效？| I
- ➢ParNew 收集器运行在多CPU的环境下，因为能够充分利用多CPU、多核心等物理硬件资源优点，能够更快速地完成垃圾收集，提高程序的吞吐量。
- ➢可是在单个CPU的环境下，ParNew收集器不比Serial收集器更高效。虽然Serial收集器是基于串行回收，可是因为CPU不须要频繁地作任务切换，所以能够有效避免多线程交互过程当中产生的一些额外开销。
由于除Serial外，目前只有ParNew GC能与CMS收集器配合工做
在程序中，开发人员能够经过选项"一XX： +UseParNewGC"手动指定使用.ParNew收集器执行内存回收任务。它表示年轻代使用并行收集器，不影响老年代。
一XX：ParallelGCThreads 限制线程数量，默认开启和CPU数据相同的线程数。.

Parallel回收器:吞吐量优先

HotSpot的年轻代中除了拥有ParNew收集器是基于并行回收的之外， Parallel Scavenge收集器一样也采用了复制算法、并行回收和"Stop the World"机制。
那么Parallel收集器的出现是否画蛇添足？
- ➢和ParNew收集器不一样，Parallel Scavenge收集器的目标则是==达到一个可控制的吞吐量==（Throughput），它也被称为吞吐量优先的垃圾收集器。
- ➢自适应调节策略也是Parallel Scavenge 与ParNew一个重要区别。
高吞吐量则能够高效率地利用CPU 时间，尽快完成程序的运算任务|，主要适合在后台运算而不须要太多交互的任务。所以，常见在服务器环境中使用。例如，那些执行批量处理、订单处理、工资支付、科学计算的应用程序。
Parallel收集器在JDK1.6时提供了用于执行老年代垃圾收集的 Parallel 0ld收集器，用来代替老年代的Serial 0ld收集器。
Parallel 0ld收集器采用了标记一压缩算法，但一样也是基于并行回收和”Stop一the一World"机制。
在程序吞吐量优先的应用场景中，Parallel 收集器和Parallel 0ld收集器的组合，在Server模式下的内存回收性能很不错。
在Java8中，默认是此垃圾收集器

参数配置

一XX： +UseParallelGC手动指定年轻代使用Parallel并行收集器执行内存回收任务。
一XX： +UseParallel0ldGc手动指定老年代都是使用并行回收收集器。
- 分别适用于新生代和老年代。默认jdk8是开启的。
- 上面两个参数，默认开启一个，另外一个也会被开启。（互相激活）
一XX： ParallelGCThreads设置年轻代并行收集器的线程数。通常地，最好与CPU数量相等，以免过多的线程数影响垃圾收集性能。
- 在默认状况下，当CPU数量小于8个， Paralle lGCThreads 的值等于CPU数量。
- 当CPU数量大于8个， ParallelGCThreads的值等于3+[5*CPU_ Count]/8]
一XX ：MaxGCPau3eMillis设置垃圾收集器最大停顿时间（即STw的时间）。单位是毫秒。
- ➢为了尽量地把停顿时间控制在MaxGCPauseMills之内，收集器在.工做时会调整Java堆大小或者其余一些参数。
- ➢对于用户来说，停顿时间越短体验越好。可是在服务器端，咱们注重高并发，总体的吞吐量。因此服务器端适合Parallel，进行控制。➢该参数使用需谨慎。
一XX：GCTimeRatio垃圾收集时间占总时间的比例（= 1 / （N + 1））用于衡量吞吐量的大小。
- ➢取值范围（0， 100）。默认值99，也就是垃圾回收时间不超过1号。
- ➢与前一个一XX：MaxGCPauseMillis参数有必定矛盾性。暂停时间越长，Radio参数就容易超过设定的比例。
一XX： +UseAdaptiveSizePolicy设置Parallel Scavenge收集器具备自适应调节策略
- 在这种模式下，年轻代的大小、Eden和Survivor的比例、晋升老年代的对象年龄等参数会被自动调整，已达到在堆大小、吞吐量和停顿时间之间的平衡点。
- 在手动调优比较困难的场合，能够直接使用这种自适应的方式，仅指定虚拟机的最大堆、目标的吞吐量（GCTimeRatio）和停顿时间（MaxGCPauseMills），让虚拟机本身完成调优工做。

CMS回收器:低延迟

在JDK1.5时期， HotSpot推出了一款在强交互应用中几乎可认为有划时代意义的垃圾收集器： CMS （Concurrent 一Mark 一 Sweep）收集器，这款收集器是HotSpot虚拟机中第一款真正意义上的并发收集器，它第一次实现了让垃圾收集线程与用户线程同时工做。
CMS收集器的关注点是尽量缩短垃圾收集时用户线程的停顿时间。停顿时间越短（低延迟）就越适合与用户交互的程序，良好的响应速度能提高用户体验。
- ➢目前很大一部分的Java应用集中在互联网站或者B/s系统的服务端上，这类应用尤为重视服务的响应速度，但愿系统停顿时间最短，以给用户带来较好的体验。CMS收集器就很是符合这类应用的需求。
CMS的垃圾收集算法采用标记一清除算法，而且也会" stop一the一world"
不幸的是，CMS 做为老年代的收集器，却没法与JDK 1.4.0 中已经存在的新生代收集器Parallel Scavenge配合工做，因此在JDK 1. 5中使用CMS来收集老年代的时候，新生代只能选择ParNew或者Serial收集器中的一个。
在G1出现以前，CMS使用仍是很是普遍的。一直到今天，仍然有不少系统使用CMS GC。

CMS整个过程比以前的收集器要复杂，整个过程分为4个主要阶段，即初始标记阶段、并发标记阶段、从新标记阶段和并发清除阶段。

初始标记（Initial一Mark）阶段：在这个阶段中，程序中全部的工做线程都将会由于. “Stop一the一World"机制而出现短暂的暂停，这个阶段的主要任务仅仅只是标记出GCRoots能直接关联到的对象。一旦标记完成以后就会恢复以前被暂停的全部应用.线程。因为直接关联对象比较小，因此这里的速度很是快。
并发标记（Concurrent一Mark）阶段：从GC Roots的直接关联对象开始遍历整个对象图的过程，这个过程耗时较长可是不须要停顿用户线程，能够与垃圾收集线程一块儿并发运行。
从新标记（Remark）阶段：因为在并发标记阶段中，程序的工做线程会和垃圾收集线程同时运行或者交叉运行，所以为了修正并发标记期间，因用户程序继续运做而致使标记产生变更的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段稍长一些，但也远比并发标记阶段的时间短。
并发清除（ Concurrent一Sweep）阶段：此阶段清理删除掉标记阶段判断的已经死亡的对象，释放内存空间。因为不须要移动存活对象，因此这个阶段也是能够与用户线程同时并发的

尽管CMS收集器采用的是并发回收（非独占式），可是在其初始化标记和再次标记这两个阶段中仍然须要执行“Stop一the一World”机制暂停程序中的工做线程，不过暂停时间并不会太长，所以能够说明目前全部的垃圾收集器都作不到彻底不须要“Stop一the一World”，只是尽量地缩短暂停时间。
因为最耗费时间的并发标记与并发清除阶段都不须要暂停工做，因此总体的回收是低停顿的。
另外，因为在垃圾收集阶段用户线程没有中断，因此在CMS回收过程当中，还应该确保应用程序用户线程有足够的内存可用。所以，CMS收集器不能像其余收集器那样等到老年代几乎彻底被填满了再进行收集，而是当堆内存使用率达到某一阈值时，便开始进行回收，以确保应用程序在CMS工做过程当中依然有足够的空间支持应用程序运行。要是CMS运行期间预留的内存没法知足程序须要，就会出现一次“Concurrent Mode Failure”失败，这时虚拟机将启动后备预案：临时启用Serial 0ld收集器来从新进行老年代的垃圾收集，这样停顿时间就很长了。
CMS收集器的垃圾收集算法采用的是标记一清除算法，这意味着每次执行完内存回收后，因为被执行内存回收的无用对象所占用的内存空间极有多是不连续的一些内存块，不可避免地将会产生一些内存碎片。那么CMS在为新对象分配内存空间时，将没法使用指针碰撞（Bump the Pointer）技术，而只可以选择空闲列表（Free List）执行内存分配。

有人会以为既然Mark Sweep会形成内存碎片，那么为何不把算法换成Mark Compact呢？
答案其实很简答，由于当并发清除的时候，用Compact整理内存的话，原来的用户线程使用的内存还怎么用呢？要保证用户线程能继续执行，前提的它运行的资源不受影响嘛。Mark Compact更适合“Stop the World”这种场景”下使用

·CMS的优势： .

并发收集
低延迟

CMS的弊端：

1）会产生内存碎片，致使并发清除后，用户线程可用的空间不足。在没法分配大对象的状况下，不得不提早触发Full GC。
2） CMS收集器对CPU资源很是敏感。在并发阶段，它虽然不会致使用户停顿，可是会由于占用了一部分线程而致使应用程序变慢，总吞吐量会下降。
3） CMS收集器没法处理浮动垃圾。可能出现“Concurrent Mode Failure" 失败而致使另外一次Full GC的产生。在并发标记阶段因为程序的工做线程和垃圾收集线程是同时运行或者交叉运行的，那么在并发标记阶段若是产生新的垃圾对象，CMS将没法对这些垃圾对象进行标记，最终会致使这些新产生的垃圾对象没有被及时回收，从而只能在下一次执行GC时释放这些以前未被回收的内存空间。

参数设置

一XX：+UseConcMarkSweepGc 手动指定使用CMS收集器执行内存回收任务。
- ➢开启该参数后会自动将一XX： +UseParNewGc打开。即： ParNew （Young区用） +CMS （0ld区用） +Serial 0ld的组合。
一XX：CMS1ni tiatingOccupanyFraction设置堆内存使用率的阈值，一旦达到该阈值，便开始进行回收。
- JDK5及之前版本的默认值为68，即当老年代的空间使用率达到68号时，会执行一 .次CMS 回收。 JDK6 5及以上版本默认值为92号
- ➢若是内存增加缓慢，则能够设置一个稍大的值，大的阈值能够有效下降CMS的触发频率，减小老年代回收的次数能够较为明显地改善应用程序性能。反之，若是应用程序内存使用率增加很快，则应该下降这个阈值，以免频繁触发老年代串行收集器。所以经过该选项即可以有效下降Full GC的执行次数。
一XX： +UseCMSCompactAtFullCollection用于指定在执行完Full GC后对内存空间进行压缩整理，以此避免内存碎片的产生。不过因为内存压缩整理过程没法并发执行，所带来的问题就是停顿时间变得更长了。
一XX：CMSFullGCsBeforeCompaction设置在执行多少次Full GC后对内存空间进行压缩整理。
一XX：ParallelCMSThreads 设置CMS的线程数量。
- CMS 默认启动的线程数是（ParallelGCThreads+3） /4， ParallelGCThreads是年轻代并行收集器的线程数。当CPU资源比较紧张时，受到CMs收集器线程的影响，应用程序的性能在垃圾回收阶段可能会很是糟糕。

小结：

HotSpot有这么多的垃圾回收器，那么若是有人问，Serial GC、 Parallel GC、Concurrent Mark Sweep GC这三个GC有什么不一样呢？
请记住如下口令：
若是你想要最小化地使用内存和并行开销，请选Serial GC；
若是你想要最大化应用程序的吞吐量，请选Parallel GC；
若是你想要最小化GC的中断或停顿时间，请选CMS GC。

JDK 后续版本中CMS的变化

JDK9新特性： CMS被标记为Deprecate了（JEP291）
- 若是对JDK 9及以上版本的HotSpot虚拟机使用参数一XX：+UseConcMarkSweepGC来开启CMS收集器的话，用户会收到一个警告信息，提示CMS将来将会被废弃。
JDK14新特性：删除CMS垃圾回收器（JEP363）
- 移除了CMS垃圾收集器，若是在JDK14中使用一XX： +UseConcMarkSweepGC的话，JVM不会报错，只是给出一个warning信息，可是不会exit。JVM会自动回退以默认GC方式启动JVM

G1回收器:区域化分代式

既然咱们已经有了前面几个强大的GC，为何还要发布Garbage First （G1）GC？
缘由就在于应用程序所应对的业务愈来愈庞大、复杂，用户愈来愈多，没有GC就不能保证应用程序正常进行，而常常形成STW的GC又跟不上实际的需求，因此才会不断地尝试对GC进行优化。G1 （Garbage一First）垃圾回收器是在Java7 update4以后引入的一个新的垃圾回收器，是当今收集器技术发展的最前沿成果之一。
与此同时，为了适应如今不断扩大的内存和不断增长的处理器数量，进一步下降暂停时间（pause time），同时兼顾良好的吞吐量。
==官方给G1设定的目标是在延迟可控的状况下得到尽量高的吞吐量，因此才担当起“全功能收集器”的重任与指望==

为何名字叫作Garbage First （G1）呢？

由于G1是一个并行回收器，它把堆内存分割为不少不相关的区域（Region）（物理上不连续的）。使用不一样的Region来表示Eden、幸存者0区，幸存者1区，老年代等。
G1 GC有计划地避免在整个Java 堆中进行全区域的垃圾收集。G1跟踪各个Region 里面的垃圾堆积的价值大小（回收所得到的空间大小以及回收所需时间的经验值），在后台维护一个优先列表，每次根据容许的收集时间，优先回收价值最大的Region。
因为这种方式的侧重点在于回收垃圾最大量的区间（Region），因此咱们给G1一个名字：垃圾优先（Garbage First）。
G1 （Garbage一First）是一款面向服务端应用的垃圾收集器，主要针对配备多核CPU及大容量内存的机器，以极高几率知足GC停顿时间的同时，还兼具高吞吐量的性能特征。
在JDK1. 7版本正式启用，移除了Experimental的标识，是JDK 9之后的默认垃圾回收器，取代了CMS回收器以及Parallel + Parallel 0ld组合。被Oracle官方称为“全功能的垃圾收集器” 。
与此同时，CMS已经在JDK 9中被标记为废弃（deprecated）。在jdk8中还不是默认的垃圾回收器，须要使用一XX： +UseG1GC来启用。

优点

与其余GC收集器相比，G1使用了全新的分区算法，其特色以下所示：

并行与并发
- ➢并行性： G1在回收期间，能够有多个Gc线程同时工做，有效利用多核计算能力。此时用户线程STW
- ➢并发性： G1拥有与应用程序交替执行的能力，部分工做能够和应用程序同时执行，所以，通常来讲，不会在整个回收阶段发生彻底阻塞应用程序的状况
分代收集
- ➢从分代上看，G1依然属于分代型垃圾回收器，它会区分年轻代和老年代，年轻代依然有Eden区和Survivor区。但从堆的结构，上看，它不要求整个Eden区、年轻代或者老年代都是连续的，也再也不坚持固定大小和固定数量。
- ➢将堆空间分为若干个区域（Region），这些区域中包含了逻辑上的年轻代和老年代。
- ➢和以前的各种回收器不一样，它同时兼顾年轻代和老年代。对比其余回收器，或者工做在年轻代，或者工做在老年代；
空间整合
- ➢CMS： “标记一清除”算法、内存碎片、若干次Gc后进行一次碎片整理
- ➢G1将内存划分为一个个的region。内存的回收是以region做为基本单位的.Region之间是复制算法，但总体上实际可看做是标记一压缩（Mark一Compact）算法，两种算法均可以免内存碎片。这种特性有利于程序长时间运行，分配大对象时不会由于没法找到连续内存空间而提早触发下一次GC。尤为是当Java堆很是大的时候，G1的优点更加明显。
可预测的停顿时间模型（即：软实时soft real一time）这是G1相对于CMS的另外一大优点，G1除了追求低停顿外，还能创建可预测的停顿时间模型，能让使用者明确指定在一个长度为M毫秒的时间片断内，消耗在垃圾收集上的时间不得超过N毫秒。
- ➢因为分区的缘由，G1能够只选取部分区域进行内存回收，这样缩小了回收的范围，所以对于全局停顿状况的发生也能获得较好的控制。
- ➢G1跟踪各个Region里面的垃圾堆积的价值大小（回收所得到的空间大小以及回收所需时间的经验值），在后台维护一个优先列表，每次根据容许的收集时间，优先回收价值最大的Region。保证了G1 收集器在有限的时间内能够获取尽量高的收集效率。
- ➢相比于CMSGC，G1未必能作到CMS在最好状况下的延时停顿，可是最差状况要.好不少。

缺点

相较于CMS，G1还不具有全方位、压倒性优点。好比在用户程序运行过程当中，G1不管是为了垃圾收集产生的内存占用（Footprint）仍是程序运行时的额外执行负载（overload）都要比CMS要高。
从经验上来讲，在小内存应用上CMS的表现大几率会优于G1，而G1在大内存应用，上则发挥其优点。平衡点在6一8GB之间。

参数设置

一XX：+UseG1GC 手动指定使用G1收集器执行内存回收任务。
一XX：G1HeapRegionSize 设置每一个Region的大小。值是2的幂，范围是1MB 到32MB之间，目标是根据最小的Java堆大小划分出约2048个区域。默认是堆内存的1/2000。
一XX：MaxGCPauseMillis 设置指望达到的最大Gc停顿时间指标（JVM会尽力实现，但不保证达到）。默认值是200ms
一xX：ParallelGCThread 设置sTw.工做线程数的值。最多设置为8
一XX：ConcGCThreads 设置并发标记的线程数。将n设置为并行垃圾回收线程数（ParallelGCThreads）的1/4左右。
一XX：Ini tiatingHeapOccupancyPercent 设置触发并发GC周期的Java堆占用率阈值。超过此值，就触发GC。默认值是45。

G1回收器的常见操做步骤

G1的设计原则就是简化JVM性能调优，开发人员只须要简单的三步便可完成调优：

第一步：开启G1垃圾收集器
第二步：设置堆的最大内存
第三步：设置最大的停顿时间

G1中提供了三种垃圾回收模式： YoungGC、 Mixed GC和Full GC，在不一样的条件下被触发。

适用场景

面向服务端应用，针对具备大内存、多处理器的机器。（在普通大小的堆里表现并不.惊喜）
最主要的应用是须要低GC延迟，并具备大堆的应用程序提供解决方案；
如：在堆大小约6GB或更大时，可预测的暂停时间能够低于0.5秒；（ G1经过每次只清理一部分而不是所有的Region的增量式清理来保证每次GC停顿时间不会过长）。
用来替换掉JDK1.5中的CMS收集器；在下面的状况时，使用G1可能比CMS好：
①超过50%的Java堆被活动数据占用；
②对象分配频率或年代提高频率变化很大；
③GC停顿时间过长（长于0. 5至1秒）。
HotSpot垃圾收集器里，除了G1之外，其余的垃圾收集器使用内置的JVM线程执行 GC的多线程操做，而G1 GC能够采用应用线程承担后台运行的GC工做，即当JVM的GC线程处理速度慢时，系统会调用应用程序线程帮助加速垃圾回收过程。

分区region,化整为零

使用G1收集器时，它将整个Java堆划分红约2048个大小相同的独立Region块，每一个Region块大小根据堆空间的实际大小而定，总体被控制在1MB到32MB之间，且为2的N次幂，即1MB， 2MB， 4MB， 8MB， 1 6MB， 32MB。能够经过一 XX：G1HeapRegionSize设定。全部的Region大小相同，且在JVM生命周期内不会被改变。
虽然还保留有新生代和老年代的概念，但新生代和老年代再也不是物理隔离的了，它们都是一部分Region （不须要连续）的集合。经过Region的动态分配方式实现逻辑_上的连续。

一个region 有可能属于Eden， Survivor 或者0ld/Tenured 内存区域。可是一个region只可能属于一个角色。图中的E表示该region属于Eden内存区域，s表示属于Survivor内存区域，0表示属于0ld内存区域。图中空白的表示未使用的内存空间。
G1垃圾收集器还增长了一种新的内存区域，叫作Humongous内存区域，如图中的H块。主要用于存储大对象，若是超过1. 5个region，就放到H。
设置H的缘由：
- 对于堆中的大对象，默认直接会被分配到老年代，可是若是它是一个短时间存在的大对象，就会对垃圾收集器形成负面影响。为了解决这个问题，G1划分了一个Humongous区，它用来专门存放大对象。若是一个H区装不下一个大对象，那么G1会寻找连续的H区来存储。为了能找到连续的H区，有时候不得不启动Full GC。G1的大多数行为都把H区做为老年代的一部分来看待。

G1回收器垃圾回收过程

G1 GC的垃圾回收过程主要包括以下三个环节：

年轻代GC （Young GC ）
老年代并发标记过程（ Concurrent Marking）
混合回收（Mixed GC ）
（若是须要，单线程、独占式、高强度的Full GC仍是继续存在的。它针对GC的评估失败提供了一种失败保护机制，即强力回收。）
顺时针， young gc 一> young gc + concurrent mark 一> Mixed GC顺序，进行垃圾回收。
应用程序分配内存，当年轻代的Eden区用尽时开始年轻代回收过程； G1的年轻代收集阶段是一个并行的独占式收集器。在年轻代回收期，G1 GC暂停全部应用程序线程，启动多线程执行年轻代回收。而后从年轻代区间移动存活对象到Survivor区间或者老年区间，也有多是两个区间都会涉及。
当堆内存使用达到必定值（默认45%）时，开始老年代并发标记过程。
标记完成马.上开始混合回收过程。对于一个混合回收期，G1 GC从老年区间移动存活对象到空闲区间，这些空闲区间也就成为了老年代的一部分。和年轻代不一样，老年代的G1回收器和其余GC不一样，G1的老年代回收器不须要整个老年代被回收，一次只须要扫描/回收一小部分老年代的Region就能够了。同时，这个老年代Region是和年轻代一块儿被回收的。
举个例子：一个web服务器，Java进程最大堆内存为4G，每分钟响应1500个请求，每45秒钟会新分配大约2G的内存。G1会每45秒钟进行一次年轻代回收，每31 个小时整个堆的使用率会达到45号，会开始老年代并发标记过程，标记完成后开始四到五次的混合回收。

记忆集与写屏障

一个对象被不一样区域引用的问题(分代引用问题)
一个Region不多是孤立的，一个Region中的对象可能被其余任意Region中对象引用，判断对象存活时，是否须要扫描整个Java堆才能保证准确？
在其余的分代收集器，也存在这样的问题（而G1更突出）
回收新生代也不得不一样时扫描老年代？
这样的话会下降MinorGC的效率；
·解决方法：
- ➢不管G1仍是其余分代收集器，JVM都是使用RememberedSet来避免全局扫描：
- ➢每一个Region都有一个对应的Remembered Set；
- ➢每次Reference类型数据写操做时，都会产生一个Write Barrier暂时中断操做； .
- ➢而后检查将要写入的引用指向的对象是否和该Reference类型数据在不一样的Region （其余收集器：检查老年代对象是否引用了新生代对象）；
- ➢若是不一样，经过CardTable把相关引用信息记录到引用指向对象的所在Region对应的Remembered Set中；
- ➢当进行垃圾收集时，在GC根节点的枚举范围加入Remembered Set；就能够保证不进行全局扫描，也不会有遗漏。

G1回收过程详解

1. 年轻代GC

JVM启动时，G1 先准备好Eden区，程序在运行过程当中不断建立对象到Eden区，当Eden空间耗尽时，G1会启动一次年轻代垃圾回收过程。
年轻代垃圾回收只会回收Eden区和Survivor区。
YGC时，首先G1中止应用程序的执行（Stop一The一World），G1建立回收集（Collection Set），回收集是指须要被回收的内存分段的集合，年轻代回收过程的回收集包含年轻代Eden区和Survivor区全部的内存分段。
而后开始以下回收过程：
- 第一阶段，扫描根。
  根是指static变量指向的对象，正在执行的方法调用链条上的局部变量等。根引用连同RSet记录的外部引用做为扫描存活对象的入口。
- 第二阶段，更新RSet.
  处理dirty card queue（见备注）中的card，更新RSet。此阶段完成后，RSet可以准确的反映老年代对所在的内存分段中对象的引用。
  - dirty card queue: 对于应用程序的引用赋值语句object.field=object，JVM会在以前和以后执行特殊的操做以在dirty card queue中入队一个保存了对象引用信息的card。在年轻代回收的时候， G1会对Dirty Card Queue中全部的card进行处理，以更新RSet，保证RSet实时准确的反映引用关系。那为何不在引用赋值语句处直接更新RSet呢？这是为了性能的须要，RSet的处理须要线程同步，开销会很大，使用队列性能会好不少。
- 第三阶段，处理RSet。
  识别被老年代对象指向的Eden中的对象，这些被指向的Eden中的对象被认为是存活的对象。
- 第四阶段，复制对象。
  此阶段，对象树被遍历，Eden区内存段中存活的对象会被复制到Survivor区中空的内存分段，Survivor区内存段中存活的对象若是年龄未达阈值，年龄会加1，达到阀值会被会被复制到01d区中空的内存分段。若是Survivor空间不够，Eden空间的部分数据会直接晋升到老年代空间。
- 第五阶段，处理引用。
  处理Soft，Weak， Phantom， Final， JNI Weak等引用。最终Eden空间的数据为空，GC中止工做，而目标内存中的对象都是连续存储的，没有碎片，因此复制过程能够达到内存整理的效果，减小碎片。

2. 并发标记过程

初始标记阶段：标记从根节点直接可达的对象。这个阶段是STW的，而且会触发一.次年轻代GC。
根区域扫描（Root Region Scanning）： G1 GC扫描Survivor区直接可达的老年代区域对象，并标记被引用的对象。这一过程必须在young GC以前完成。
并发标记（Concurrent Marking）：在整个堆中进行并发标记（和应用程序并发执行），此过程可能被young GC中断。在并发标记阶段，若发现区域对象中的全部对象都是垃圾，那这个区域会被当即回收。同时，并发标记过程当中，会计算每一个区域的对象活性（区域中存活对象的比例）。
再次标记（Remark）：由于应用程序持续进行，须要修正上一次的标记结果。是STW的。G1中采用了比CMS更快的初始快照算法：snapshot一at一the一beginning （SATB）。
独占清理（cleanup，STW）：计算各个区域的存活对象和GC回收比例，并进行排序，识别能够混合回收的区域。为下阶段作铺垫。是STW的。
- ➢这个阶段并不会实际上去作垃圾的收集
并发清理阶段：识别并清理彻底空闲的区域。

3. 混合回收

当愈来愈多的对象晋升到老年代oldregion时，为了不堆内存被耗尽，虚拟机会触发一个混合的垃圾收集器，即Mixed GC，该算法并非一个0ldGC，除了回收整个Young Region，还会回收一部分的0ldRegion。这里须要注意：是一部分老年代，而不是所有老年代。能够选择哪些0ldRegion进行收集，从而能够对垃圾回收的耗时时间进行控制。也要注意的是Mixed GC并非Fu1l GC。

并发标记结束之后，老年代中百分百为垃圾的内存分段被回收了，部分为垃圾的内存分段被计算了出来。默认状况下，这些老年代的内存分段会分8次（能够经过一XX： G1MixedGCCountTarget设置）被回收。
混合回收的回收集（Collection Set）包括八分之一的老年代内存分段，Eden区内存分段，Survivor区内存分段。混合回收的算法和年轻代回收的算法彻底同样，只是回收集多了老年代的内存分段。具体过程请参考上面的年轻代回收过程。
因为老年代中的内存分段默认分8次回收，G1会优先回收垃圾多的内存分段。垃圾占内存分段比例越高的，越会被先回收。而且有一个阈值会决定内存分段是否被回收，一xX： G1MixedGCLiveThresholdPercent，默认为65%，意思是垃圾占内存分段比例要达到65%才会被回收。若是垃圾占比过低，意味着存活的对象占比高，在复制的时候会花费更多的时间。
混合回收并不必定要进行8次。有一个阈值一Xx： G1HeapWastePercent，默认值为10%，意思是容许整个堆内存中有10%的空间被浪费，意味着若是发现能够回收的垃圾占堆内存的比例低于10%，则再也不进行混合回收。由于GC会花费不少的时间可是回收到的内存却不多。

4. Full GC

G1的初衷就是要避免Full GC的出现。可是若是上述方式不能正常工做，G1会中止应用程序的执行（Stop一 The一World），使用单线程的内存回收算法进行垃圾回收，性能会很是差，应用程序停顿时间会很长。
要避免Full GC的发生，一旦发生须要进行调整。何时会发生Full GC呢？好比堆内存过小，当G1在复制存活对象的时候没有空的内存分段可用，则会回退到full gc，这种状况能够经过增大内存解决。
致使G1Full GC的缘由可能有两个：

1.Evacuation的时候没有足够的to一 space来存放晋升的对象；
2.并发处理过程完成以前空间耗尽。

补充

从Oracle官方透露出来的信息可获知，回收阶段（Evacuation）其实.本也有想过设计成与用户程序一块儿并发执行，但这件事情作起来比较复杂，考虑到G1只是回收一部分Region，停顿时间是用户可控制的，因此并不迫切去实现，而选择把这个特性放到了G1以后出现的低延迟垃圾收集器（即ZGC）中。另外，还考虑到G1不是仅仅面向低延迟，停顿用户线程可以最大幅度提升垃圾收集效率，为了保证吞吐量因此才选择了彻底暂停用户线程的实现方案。

优化建议

年轻代大小
- ➢避免使用一Xmn或一XX：NewRatio等相关选项显式设置年轻代大小➢固定年轻代的大小会覆盖暂停时间目标
暂停时间目标不要太过严苛
- G1 GC的吞吐量目标是90%的应用程序时间和10%的垃圾回收时间
- 评估G1 GC的吞吐量时，暂停时间目标不要太严苛。目标太过严苛表示你愿意承受更多的垃圾回收开销，而这些会直接影响到吞吐量。

垃圾回收器总结

截止JDK 1.8，一共有7款不一样的垃圾收集器。每一款不一样的垃圾收集器都有不一样的特色，在具体使用的时候，须要根据具体的状况选用不一样的垃圾收集器。

不一样厂商、不一样版本的虚拟机实现差异很大。HotSpot 虚拟机在JDK7/8后全部收集器及组合（连线），以下图：

1.两个收集器间有连线，代表它们能够搭配使用： Serial/Serial 0ld、Serial /CMS、ParNew/Serial 0ld、ParNew/CMS、 Parallel Scavenge/Serial 01d、Parallel Scavenge/Parallel 0ld、G1；
2.其中Serial 0ld做为CMS出现"Concurrent Mode Failure"失败的后备预案。
3.（红色虚线）因为维护和兼容性测试的成本，在JDK 8时将Serial+CMS、 ParNew+Serial 0ld这两个组合声明为Deprecated （JEP 173），并在JDK 9中彻底取消了这些组合的支持（JEP214），即：移除。
4.（绿色虚线）JDK 14中：弃用ParallelScavenge 和Serial0ld GC组合（JEP 366）
5.（青色虚线）JDK 14中：删除CMS垃圾回收器（JEP 363 ） GC发展阶段： Serial => Parallel （并行） => CMS （并发） => G1 => ZGC

怎么选择垃圾回收器

Java垃圾收集器的配置对于JVM优化来讲是一个很重要的选择，选择合适的垃圾收集器可让JVM的性能有一个很大的提高。
怎么选择垃圾收集器？
- 1.优先调整堆的大小让JVM自适应完成。
- 2.若是内存小于100M，使用串行收集器
- 3.若是是单核、单机程序，而且没有停顿时间的要求，串行收集器
- 4.若是是多CPU、须要高吞吐量、容许停顿时间超过1秒，选择并行或者JVM本身选择
- 5.若是是多CPU、追求低停顿时间，需快速响应（好比延迟不能超过1秒，如互联网应用），使用并发收集器
- 官方推荐G1，性能高。如今互联网的项目，基本都是使用G1。
最后须要明确一一个观点：
- 1.没有最好的收集器，更没有万能的收集；
- 2.调优永远是针对特定场景、特定需求，不存在一劳永逸的收集器

GC日志分析

经过阅读GC日志，咱们能够了解Java虛拟机内存分配与回收策略。内存分配与垃圾回收的参数列表

一XX： +PrintGC 输出Gc日志。相似：一verbose：gc
一XX： +PrintGCDetails 输出GC的详细日志
一XX： +PrintGCTimeStamps 输出GC的时间戳（以基准时间的形式）
一XX： +PrintGCDateStamps输出GC的时间戳（以日期的形式，如2013一05一04T21 ： 53：59.234+0800 ）
一XX： +PrintHeapAtGC 在进行GC的先后打印出堆的信息
一Xloggc：. . /logs/gc. log日志文件的输出路径

+PrintGC

打开GC日志：一verbose：gc
这个只会显示总的GC堆的变化，以下：

[GC （Allocation Failure） 80832K一>19298K（227840K），0.0084018 secs]
[GC （Metadata GC Threshold） 109499K一>21465K （228352K），0.0184066 secs]
[Full GC （Metadata GC Threshold） 21 465K一>16716K （201728K），0.0619261 secs ]
复制代码

参数解析：

GC、Full GC： GC的类型，GC只在新生代上进行，Full GC包括永生代，新生代， 老年代。
Allocation Failure： GC发生的缘由。
80832K一> 19298K：堆在GC前的大小和GC后的大小。
228840k：如今的堆大小。
0.0084018 secs： GC持续的时间。
复制代码

PrintGCDetails

-打开GC日志： 一verbose：gc一 XX： +PrintGCDetaiis

输入信息以下：

[GC （Allocation Failure） [ PSYoungGen： 70640K一> 10116K（141312K） ] 80541K一>20017K （227328K），0.0172573 secs] [Times： user=0.03 sys=0.00， real=0.02 secs ]
[GC （Metadata GC Threshold） [PSYoungGen：98859K一>8154K（142336K） ] 108760K一>21261K （228352K），
0.0151573 secs] [Times： user=0.00 sys=0.01， real=0.02 secs]
[Full GC （Metadata GC Threshold） [PSYoungGen： 8154K一>0K（142336K） ] [ParOldGen： 13107K一>16809K（62464K） ] 21261K一>16809K （204800K），[Metaspace： 20599K一>20599K （1067008K） ]，0.0639732 secs]
[Times： user=0.14 sys=0.00， real=0.06 secs]
复制代码

参数解析：

GC，Full FC：一样是GC的类型
Allocation Failure： GC缘由
PSYoungGen：使用了Parallel Scavenge并行垃圾收集器的新生代GC先后大小的变化
ParOldGen：使用了Parallel Old并行垃圾收集器的老年代Gc先后大小的变化
Metaspace： 元数据区GC先后大小的变化，JDK1.8中引入了 元数据区以替代永久代
xxx secs ： 指Gc花费的时间
Times： user： 指的是垃圾收集器花费的全部CPU时间，sys： 花费在等待系统调用或系统事件的时间， real ：GC从开始到结束的时间，包括其余进程占用时间片的实际时间。
复制代码

PrintGCTimeStamps

打开GC日志： 一verbose：gc 一XX： +PrintGCDetails 一XX：+PrintGCTimeStamps 一 XX： +PrintGCDateStamps
输入信息以下：

2019一09一24T22：15：24.518+0800：3.287： [GC（Allocation Failure） [ PSYoungGen： 1361 62K一>5113K（136192K） ] 141425K一>17632K （222208K） ，0.0248249 secs] [Times： user=0.05sys=0.00， real=0.03 secs ]
2019一09一24T22：15：25.559+0800：4.329： [ GC（Metadata GC Threshold）[PSYoungGen：97578K一>10068K（274944K） ] 110096K一>22658K （360960K），0.0094071 secs]
[Times： user=0. 00sys=0.00， real=0. 01 secs]
2019一09一24T22：15：25.569+0800：4.338： [Full GC （Metadata GC Threshold）[ PSYoungGen：10068K一>0K（274944K） ] [ ParoldGen： 12590K一>13564K （56320K） ] 22658K一>13564K （331264K） ，
[Metaspace： 20590K一>20590K（1067008K）]， 0. 0494875 secs]
[Times： user=0.17 sys=0. 02，real=0.05 secs ]     
复制代码

说明：带上了日期和时间

补充说明

"[GC"和"[Full GC"说明了此次垃圾收集的停顿类型，若是有"Full"则说明GC发生了"StopThe World"
使用Serial收集器在新生代的名字是De fault New Generation，所以显示的是" [DefNew"
使用ParNew收集器在新生代的名字会变成" 【ParNew"，意思是"Parallel New Generation"
使用Parallel Scavenge收集器在新生代的名字是" 【PSYoungGen"
老年代的收集和新生代道理同样，名字也是收集器决定的
使用G1收集器的话，会显示为"garbage一 first heap"
Allocation Failure 代表本次引发GC的缘由是由于在年轻代中没有足够的空间可以存储新的数据了。
[PSYoungGen： 5986K一>696K（8704K）] 5986K一> 704K （9216K）中括号内： GC回收前年轻代大小，回收后大小，（年轻代总大小）括号外： GC回收前年轻代和老年代大小，回收后大小，（年轻代和老年代总大小）
user表明用户态回收耗时，sys 内核态回收耗时， rea实际耗时。因为多核的缘由，时间总和可能会超过real时间

Minor GC

Full GC

例

/**
 * 在jdk7 和 jdk8中分别执行
 * -verbose:gc -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=8 -XX:+UseSerialGC
 */
public class GCLogTest1 {
    private static final int _1MB = 1024 * 1024;

    public static void testAllocation() {
        byte[] allocation1, allocation2, allocation3, allocation4;
        allocation1 = new byte[2 * _1MB];
        allocation2 = new byte[2 * _1MB];
        allocation3 = new byte[2 * _1MB];
        allocation4 = new byte[4 * _1MB];
    }

    public static void main(String[] agrs) {
        testAllocation();
    }
}
复制代码

日志分析工具使用

能够用一些工具去分析这些gc日志。
经常使用的日志分析.工具备： GCViewer、GCEasy、GCHisto、GCLogViewer 、Hpjmeter、garbagecat等。

垃圾回收器的新发展

GC仍然处于飞速发展之中，目前的默认选项G1 GC在不断的进行改进，不少咱们原来认为的缺点，例如串行的Full GC、Card Table扫描的低效等，都已经被大幅改进，例如，JDK 10之后，Fu1l GC已是并行运行，在不少场景下，其表现还略优于Parallel GC的并行Full GC实现。
即便是Serial GC，虽然比较古老，可是简单的设计和实现未必就是过期的，它自己的开销，无论是GC相关数据结构的开销，仍是线程的开销，都是很是小的，因此随着云计算的兴起，在Serverless等新的应用场景下，Serial GC找到了新的舞台。
比较不幸的是CMS GC，由于其算法的理论缺陷等缘由，虽然如今还有很是大的用户群体，但在JDK9中已经被标记为废弃，并在JDK14版本中移除。

JDK11 新特性

JEP318 : Epsilon: A No一Op Garbage Collector (Epsilon 垃圾回收器,"No一Op (无操做) "回收器) http: / /openidk.java.net/ieps/318
JEP333: ZGC: A Scalable Low一 Latency ;Garbage Collector (Experimental) ( ZGC:可伸縮的低延退竝坂回收器，处于试验性阶段)

Open JDK12的Shenandoah GC

如今G1回收器已成为默认回收器好几年了。
咱们还看到了引入了两个新的收集器： ZGC （ JDK11出现）和Shenandoah（Open JDK12）。
- ➢主打特色：低停顿时间

Open JDK12 的Shenandoah GC：低停顿时间的GC （实验性）

Shenandoah，无疑是众多GC中最孤独的一个。是第一款不禁Oracle公司团队领导开发的HotSpot垃圾收集器。不可避免的受到官方的排挤。好比号称OpenJDK和OracleJDK没有区别的Oracle公司仍拒绝在OracleJDK12中支持Shenandoah。
Shenandoah垃圾回收器最初由RedHat进行的一项垃圾收集器研究项目PauselessGC的实现，旨在针对JVM上的内存回收实现低停顿的需求。在2014年贡献给OpenJDK。
Red Hat研发Shenandoah团队对外宣称，Shenandoah垃圾回收器的暂停时间与堆大小无关，这意味着不管将堆设置为200MB仍是200GB，99.9%的目标均可以把垃圾收集的停顿时间限制在十毫秒之内。不过实际使用性能将取决于实际工做堆的大小和工做负载。
这是RedHat在2016年发表的论文数据，测试内容是使用Es对200GB的维基百科数据进行索引。从结果看：
- 停顿时间比其余几款收集器确实有了质的飞跃，但也未实现最大停顿时间控制在十毫秒之内的目标。
- 而吞吐量方面出现了明显的降低，总运行时间是全部测试收集器里最长的。
Shenandoah GC的弱项：高运行负担下的吞吐量降低。
Shenandoah GC的强项：低延迟时间。

革命性的ZGC

官网连接
ZGC与Shenandoah目标高度类似，在尽量对吞吐量影响不大的前提下，实如今任意堆内存大小下均可以把垃圾收集的停顿时间限制在十毫秒之内的低延迟。
《深刻理解Java虚拟机》一书中这样定义ZGC： ZGC收集器是一款基于Region内存布局的，（暂时）不设分代的，使用了读屏障、染色指针和内存多重映射等技术来实现可并发的标记一压缩算法的，以低延迟为首要目标的一款垃圾收集器。
ZGC的工做过程能够分为4个阶段：并发标记一并发预备重分配一并发重分配一并发重映射等。
ZGC几乎在全部地方并发执行的，除了初始标记的是sTW的。因此停顿时间.几乎就耗费在初始标记上，这部分的实际时间是很是少的。

测试数据如图:
劣势比较

优点比较

在ZGC的强项停顿时间测试上，它绝不留情的将Parallel、G1拉开了两个数量级的差距。不管平均停顿、958停顿、998停顿、99. 98停顿，仍是最大停顿时间，ZGC 都能绝不费劲控制在10毫秒之内。

JDK14新特性

JEP 364： ZGC应用在macOS上
JEP 365： ZGC应用在windows上 JDK14以前，ZGC仅Linux才支持

尽管许多使用ZGC的用户都使用类Linux的环境，但在Windows和macOS 上，人们也须要ZGC进行开发部署和测试。许多桌面应用也能够从ZGC中受益。所以，ZGC特性被移植到了Windows和macOs.上。
如今mac或Windows 上也能使用zGC了，示例以下：一XX： +Unloc kExperimentalVMOptions 一XX： +UseZGC .

其余垃圾回收器:AliGC

AliGC是阿里巴巴JVM团队基于G1算法，面向大堆（LargeHeap）应用场景。指定场景下的对比：固然，其余厂商也提供了各类独具一格的GC实现，例如比较有名的低延迟GC，Zing （ www.infoq.com/articles/az…)

JVM学习代码及笔记（陆续更新中...）

【代码】
github.com/willShuhuan…
【笔记】
JVM_01 简介
 JVM_02 类加载子系统
 JVM_03 运行时数据区1- [程序计数器+虚拟机栈+本地方法栈]
JVM_04 本地方法接口
 JVM_05 运行时数据区2-堆
 JVM_06 运行时数据区3-方法区
 JVM_07 运行时数据区4-对象的实例化内存布局与访问定位+直接内存
 JVM_08 执行引擎（Execution Engine）
JVM_09 字符串常量池StringTable
JVM_10 垃圾回收1-概述+相关算法
 JVM_11 垃圾回收2-垃圾回收相关概念
 JVM_12 垃圾回收3-垃圾回收器