万字长文超详细讲解垃圾回收(图文+代码)

红太狼 2023-01-07 01:25 127阅读 0赞

### 开篇 ###

##### 什么场景下该使用垃圾回收策略 #####

*  在对内存要求苛刻的场景：想办法提高对象的回收效率，多回收掉一些对象，腾出更多内存
 *  在CPU使用率高的情况下：降低高并发时垃圾回收的频率，让CPU更多的去执行业务而不是垃圾回收

##### 垃圾回收发生在哪个区域 #####

我们可以再看一下JVM内存结构(详情可查看[《图解JVM内存结构》][JVM])  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70]  
**堆** 和 **方法区** 是线程共享的，这两块才需要关注垃圾回收

*  堆：是发生垃圾回收的主要区域，主要回收我们创建的对象
 *  方法区： 回收废弃的常量以及不需要使用的类

##### 对象在什么时候能够被回收 #####

有两种方法判断对象是否被回收

*  **引用计数法**：通过对象的引用计数器来判断该对象是否被引用
 *  **可达性分析**(目前Java使用的方法)：以根对象(GC Roots)作为起点向下搜索，走过的路径被称为引用连(Reference Chain)，如果某个对象到根对象没有引用链相连时，就认为这个对象是不可达的，可以回收

##### 根对象(GC Roots)包括哪些对象 #####

*  虚拟机栈(栈帧中的本地变量表)中引用的对象
 *  方法区中类静态属性引用的对象
 *  方法区中常量引用的对象
 *  本地方法栈中JNI(即Native方法)引用的对象

##### 引用类型有哪些 #####

*  强引用(Strong Refrence)
    
     *  例如`Object obj = new Object()`的引用
     *  只要强引用在，永远不会回收被引用的对象
 *  软引用(Soft Reference)
    
     *  形如`SoftReference<String> sr = new SoftReference<>("hello")`
     *  是用来描述一些有用但非必须的对象
     *  软引用关联的对象，只有存在内存不足的时候才会回收
 *  弱引用(Weak Reference)
    
     *  形如`WeakReference<String> sr = new WeakReference<>("hello")`
     *  弱引用也是用来描述非必需对象的
     *  无论内存是否充足，都会回收被弱引用关联的对象
 *  虚引用(Phantom Reference)
    
     *  形如
    
        RefrenceQueue<String> queue = new RefrenceQueue<>();
        PhantomReference<String> pr = new PhantomReference<>("hello", queue);
    
     *  不影响对象的生命周期，如果一个对象**只有**虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动，必须和引用队列(RefrenceQueue)配合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入了引用队列，那么就可以在所引用对象的内存被回收之前采取必要的行动。

##### 可达性算法注意点 #####

一个对象即时不可达，也不一定会被回收  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 1]

以下面的代码为例：

public class GCTest { 
        private static GCTest obj;
    
        @Override
        protected void finalize() throws Throwable { 
            super.finalize();
            System.out.println("finalize被调用了");
            obj = this;
        }
    
        public static void main(String[] args) throws InterruptedException { 
            obj = new GCTest();
            obj = null;
            System.gc();
    
            Thread.sleep(1000L);
            if (obj == null) { 
                System.out.println("obj == null");
            } else { 
                System.out.println("obj可用");
            }
    
            Thread.sleep(1000L);
            obj = null;
            System.gc();
            if (obj == null) { 
                System.out.println("obj == null");
            } else { 
                System.out.println("obj可用");
            }
        }
    }

运行打印结果如下：

> finalize被调用了  
> obj可用  
> obj == null

理论上在第一次执行以下代码时，obj会被强制回收

obj = null;
    System.gc();

但是因为为在`finalize`中，我们使用`obj = this;`重新进行了赋值，意味着对象在finalize()中重新建立了连接，所以不会被回收，从而打印`obj可用`

然后第二次执行以下代码时，虚拟机已经调用过finalize()，所以触发`无必要`分支，进行了回收

obj = null;
    System.gc();

### 垃圾回收算法 ###

#### 三种基础回收算法： ####

**标记-清除(Mark-Sweep)**

1.  标记需要回收的对象
2.  清理掉要回收的对象  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 2]  
    从上图可以看出，部分对象被回收后，内存中会存在大量碎片化的地址，浪费空间

**标记-整理(Mark-Compact)**

1.  标记需要回收的对象
2.  把所有的存活对象压缩到内存的一端
3.  清理掉边界外的所有空间  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 3]

**复制(Copy)**

1.  把内存分为两块，每次只使用一块
2.  将正在使用的内存中的存活对象复制到未使用的内存中去，然后清除掉正在使用的内存中的所有对象
3.  交换两个内存的角色，等待下次回收  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 4]  
    **算法对比**

<table> 
 <thead> 
  <tr> 
   <th>回收算法</th> 
   <th>优点</th> 
   <th>缺点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>标记-清除</td> 
   <td>实现简单</td> 
   <td>存在内存碎片、分配内存速度会受影响</td> 
  </tr> 
  <tr> 
   <td>标记-整理</td> 
   <td>无碎片</td> 
   <td>整理存在开销</td> 
  </tr> 
  <tr> 
   <td>复制</td> 
   <td>性能好、无碎片</td> 
   <td>内存利用率低</td> 
  </tr> 
 </tbody> 
</table>

**两种Java里有两种相对综合的回收算法**

*  分代收集算法：把内存分成多个区域，不同区域使用不同的回收算法回收对象
 *  增量算法：每次只收集一小片区域的内存空间垃圾

#### 分代收集算法 ####

优势：

*  更有效的清除不再需要的对象
 *  提升了垃圾回收的效率

方法：

*  新生代回收(Minor GC | Young GC)
 *  老年代回收(Major GC)
 *  清理整个堆(Full GC)  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 5]

对象在被创建时，会先被放到`伊甸园`，当伊甸园的内存满了之后，会将要被回收的内存放到`存活区`中的`From survivor`或`To survivor`，存活区内触发回收机制时，会使用`复制`算法，将  
`From survivor`内的对象复制到`To survivor`或将`To survivor`内的对象复制到`From survivor`，每次复制会将对象的`年龄+1`，当对象年龄达到阈值(默认15)时，会将其放入`老年代`

上面只是一个标准流程，也会有其他情况，例如：

*  新建的对象不一定分配到伊甸园
    
     *  对象大于-XX:PretenureSizeThreshold，就会直接分配到老年代
     *  新生代空间不够
 *  对象不一定要达到年龄才进入老年代
    
     *  动态年龄：如果Survivor空间中所有相同年龄对象大小的总和大于Survivor空间的一半，那么年龄大于等于该年龄的对象就可以直接进入老年代

调优原则：

*  合理设置Survivor区域的大小，避免内存浪费
 *  让GC尽量发生在新生代，尽量减少Full GC的发生

相关参数：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>默认</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>-XX:NewRatio=n</td> 
   <td>2</td> 
   <td>老年代:新生代内存大小比值</td> 
  </tr> 
  <tr> 
   <td>-XX:SurvivorRatio=n</td> 
   <td>8</td> 
   <td>伊甸园：Survivor区域内存大小比值</td> 
  </tr> 
  <tr> 
   <td>-XX:PrerenureSizeThreshold=n</td> 
   <td>0</td> 
   <td>对象大小该值就在老年代分配，0表示不做限制</td> 
  </tr> 
  <tr> 
   <td>-Xms</td> 
   <td>-</td> 
   <td>需小堆内存</td> 
  </tr> 
  <tr> 
   <td>-Xmx</td> 
   <td>-</td> 
   <td>需大堆内存</td> 
  </tr> 
  <tr> 
   <td>-Xmn</td> 
   <td>-</td> 
   <td>新生代大小</td> 
  </tr> 
  <tr> 
   <td>-XX:</td> 
   <td>启用</td> 
   <td>忽略掉System.gc()的调用</td> 
  </tr> 
  <tr> 
   <td>-XX:</td> 
   <td>-</td> 
   <td>新生代初始内存大小</td> 
  </tr> 
  <tr> 
   <td>-XX:</td> 
   <td>-</td> 
   <td>新生代最大内存</td> 
  </tr> 
 </tbody> 
</table>

### 垃圾收集器 ###

`垃圾收集算法`是为实现垃圾回收提供理论支持，`垃圾收集器`利用算法实现垃圾回收的实践落地，以下是java中比较主流的垃圾收集器  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 6]  
在正式探讨垃圾收集器之前，先普及几个术语：

*  **STW**(Stop The World)
    
     *  也叫全局停顿，Java代码停止运行，native代码继续运行，但不能与JVM进行交互。
     *  原因：多半由于垃圾回收导致，也可能由Dump线程、死锁检查、Dump堆导致。
     *  危害：服务停止、没有响应；主从切换、危害生产环境。
 *  **并行收集** 与 **并发收集**
    
     *  并行收集：指多个垃圾收集线程并行工作，但是收集的过程中，用户线程还是处于等待状态
     *  并发收集：指用户线程与垃圾收集线程同时工作
 *  **吞吐量**
    
     *  CPU用于运行用户代码的时间与CPU总消耗时间的比值
     *  公式： 运行用户代码时间 / ( 运行用户代码时间 + 垃圾收集时间 )

下面开始正式介绍垃圾收集器：

##### Serial收集器 #####

最基本的、发展历史最悠久的收集器，使用`复制算法`

*  特点：
    
     *  单线程
     *  简单、高效
     *  收集过程全程**STW**
 *  适用场景
    
     *  客户端程序，应用以-client模式运行，默认使用的就是Serial
     *  单核机器

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 7]  
用户线程运行到一个安全点后全部暂停，然后由一个收集器线程去回收垃圾，回收完成之后用户线程才能继续执行

##### ParNew收集器 #####

Serial收集器的多线程版本，除使用了多线程以外，其他和Serial收集器一样，包括：JVM参数、Stop The World的表现、垃圾收集算法都是一样的。

*  特点：
    
     *  多线程
     *  可以使用-XX:ParallelGCThreads设置垃圾收集的线程数
 *  适用场景：主要和CMS收集器配合使用  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 8]  
    与Serial收集器一样，也是所有用户线程运行到一个安全点后全部暂停，但是这里是使用多线程进行垃圾回收，回收完成之后用户线程继续执行

##### Paraller Scavenge收集器 #####

也叫吞吐量优先收集器，采用的也是复制算法，也是并行的多线程收集器，这一点和ParNew类似

*  特点：
    
     *  可以达到一个可控制的吞吐量
        
         *  \-XX:MaxGCPauseMillis：控制最大的垃圾收集器停顿时间（尽力）
         *  \-XX:FCTimeRatio：设置吞吐量的大小，取值0-100，系统花费不超过1/(1+n)的时间用于垃圾收集
     *  自适应GC策略：可用-XX:+UseAdptiveSizePolicy打开
        
         *  打开自适应策略后，无需手动设置新生代的大小(-Xmn)、Eden与Survivor区的比例(-XX:SurvivorRatio)等参数
         *  虚拟机会自动根据系统的运行状况收集性能监控信息，动态地调整这些参数，从而达到最优的停顿时间以及最高的吞吐量
 *  适用场景：注重吞吐量的场景

##### Serial Old收集器 #####

Serial收集器的老年代版本，采用`标记-整理算法`

*  适用场景
    
     *  可以和Serila/ParNew/Paraller Scavenge这三个新生代的垃圾收集器配合使用
     *  CMS收集器出现故障的时候，会用Serial Old作为后备

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 9]  
可以发现，除了使用算法不一样以外，其他基本和Serial收集器一样

##### Paraller Old收集器 #####

Paraller Scavenge收集器的老年代版本，也是使用`标记-整理算法`

*  特点：只能和Paraller Scavenge配合使用
 *  适用场景：关注吞吐量的场景

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 10]

##### CMS收集器 #####

Concurrent Mark Sweep，并发收集器，使用`标记-清除`算法

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 11]  
执行步骤如下：

*  初始标记（inital mark）
    
     *  标记GC Roots能直接关联到的对象
     *  Stop The World
 *  并发标记（concurrent mark）
    
     *  找出所有GC Roots能关联到的对象
     *  并发执行，无Stop The World
 *  并发预清理（concurrent-preclean）
    
     *  重新标记那些在并发标记阶段，引用被更新的对象，从而减少后面重新标记阶段的工作量
     *  并发执行，无Stop The World
     *  可使用XX:-CMSPrecleaningEnabled关闭并发预清理阶段，默认打开
 *  并发可中止的预清理阶段（concurrent-abortable-preclean）
    
     *  和并发预清理做的事情一样，并发执行，无Stop The World
     *  当Eden的使用量大于CMSScheduleRemarkEdenSizeThreshold的阈值(默认2M)时，才会执行该阶段
     *  主要作用：允许我们能够控制预清理阶段的结束时机。比如扫描多长时间(CMSMaxAbortablePrecleanTime，默认5秒)或者Eden区使用占比达到一定阈值（CMSScheduleRemarkEdenPenetration，默认50%）就结束本阶段
 *  重新标记（remark）
    
     *  修正并发标记期间，因为用户程序继续运行，导致标记发生变动的那些对象的标记
     *  **一般来说**，重新标记花费的时间会比初始标记阶段长一些，但比并发标记的时间短
     *  存在Stop The World
 *  并发清除（concurrent sweep）
    
     *  基于标记结果，清除掉要清除前面标记出来的垃圾
     *  并发执行，无Stop The World
 *  并发重置（concurrent reset）
    
     *  清理本次CMS GC的上下文信息，为下一次GC做准备

优点：

*  stop the world的时间比较短
 *  大多过程并发执行

缺点：

*  CPU资源比较敏感
    
     *  并发阶段可能导致应用吞吐量的降低
 *  无法处理浮动垃圾
 *  不能等到老年代几乎满了才开始收集
    
     *  预留的内存不够 -> Concurrent Mode Failure -> Serial Old作为后备
     *  可使用CMSInitiatingOccupancyFraction设置老年代占比达到多少就触发垃圾收集，默认68%
 *  内存碎片
    
     *  标记-清除导致碎片的产生
     *  USeCMSCompactAtFullCollection：在完成Full GC后是否要进行内存碎片整理，默认开启
     *  CMSFullGCsBeforeCompaction：进行几次Full GC后就进行一次内存碎片整理，默认0

适用场景：希望系统停顿时间短，响应速度快的场景，比如各种服务器应用程序

##### G1收集器 #####

Garbge First：面向服务器端应用的垃圾收集器

内存布局：  
G1把整个java堆划分成若干个大小相等的区域（Region），Region的大小可通过参数`-XX:G1HeapRegionSize`指定Region的大小，取值范围为1MB~32MB，应为2的N次幂  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 12]

设计思想：

*  内存分块（Region）
 *  跟踪每个Region里面的垃圾堆积的价值大小
 *  构建一个优先列表，根据允许的收集时间，优先回收价值高的Region

垃圾收集机制：

*  Young GC
    
     *  所有Eden Region都满了的时候，就会触发Young GC
     *  伊甸园里面的对象会转移到Survivor Region里面去
     *  原先Survivor Region中的对象转移到新的Survivor Region中，或者晋升到Old Region
     *  空闲Region会被放入空闲列表中，等待下次被使用
 *  Mixed GC
    
     *  老年代大小占整个堆的百分比达到一定阈值（可用-XX:InitiatingHeapOccupancyOercent指定，默认45%），就触发
     *  Mixed GC会回收所有Young GC，同时回收**部分**Old Region
 *  Full GC
    
     *  复制对象内存不够，或者无法分配足够内存（比如巨型对象没有足够的连续分区分配）时，会触发Full GC
     *  Full GC模式下，使用Serial Old模式
     *  G1优化原则：尽量减少Full GC的发生
        
         *  增加预留内存（增大-XX:G1ReservePercent，默认为堆的10%）
         *  更早地回收垃圾（减少-XX:InitiatingHeapOccupancyPercent，老年代达到该值就触发Mixed GC，默认45%）
         *  增加并发阶段使用的线程数（增大-XX:ConcGCThreads）

**Mixed GC**是G1巧妙的设计思路的提现，执行过程如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 13]

*  初始标记（Initial Marking）
    
     *  标记GC Roots能直接关联到的对象，和CMS类似
     *  存在Stop The World
 *  并发标记（concurrent mark）
    
     *  同CMS的并发标记
     *  并发执行，无Stop The World
 *  最终标记（Final Marking）
    
     *  修正在并发标记期间引起的变动
     *  存在Stop The World
 *  筛选回收（Live Data Counting and Evacuation）
    
     *  对各个Region的回收价值和成本进行排序
     *  根据用户所期望的停顿时间（MaxGCPauseMillis）来指定回收计划，并选择一些Region回收
     *  回收过程：
        
         *  选择一系列Region构成一个回收集
         *  把决定回收的Region中的存货对象复制到空的Region中
         *  删除调需要回收的Region -> 无内存碎片
         *  存在Stop The World

特点：

*  可以作用在整个堆
 *  可控的停顿
    
     *  MaxGCPauseMillis=200
 *  无内存碎片

使用场景：

*  占用内存较大的应用（6G以上）
 *  替换CMS垃圾收集器

### 垃圾收集器相关JVM参数总结 ###

以下参数基于JDK 8整理

<table> 
 <thead> 
  <tr> 
   <th>收集器</th> 
   <th>参数及默认值</th> 
   <th>备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Serial</td> 
   <td>-XX:+UseSerialGC</td> 
   <td>虚拟机在Client模式下的默认值，开启后，使用 Serial + Serial Old 的组合</td> 
  </tr> 
  <tr> 
   <td>ParNew</td> 
   <td>-XX:+UseParNewGC</td> 
   <td>开启后，使用ParNew + Serial Old的组合</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:ParallelGCThreads=n</td> 
   <td>设置垃圾收集器在并行阶段使用的垃圾收集线程数，当逻辑处理器数量小于8时，n的值与逻辑处理器数量相同；如果逻辑处理器数量大于8个，则n的值大约为逻辑处理器数量的5/8，大多数情况下是这样，除了较大的SPARC系统，其中n的值约为逻辑处理器的5/16。</td> 
  </tr> 
  <tr> 
   <td>Parallel Scavenge</td> 
   <td>-XX:+UseParallelGC</td> 
   <td>虚拟机在Server模式下的默认值，开启后，使用 Parallel Scavenge + Serial Old的组合</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:MaxGCPauseMillis=n</td> 
   <td>收集器尽可能保证单次内存回收停顿的时间不超过这个值，但是并不保证不超过该值</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:GCTimeRatio=n</td> 
   <td>设置吞吐量的大小，取值范围0-100，假设 GCTimeRatio 的值为 n，那么系统将花费不超过 1/(1+n) 的时间用于垃圾收集</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:+UseAdaptiveSizePolicy</td> 
   <td>开启后，无需人工指定新生代的大小（-Xmn）、 Eden和Survisor的比例（-XX:SurvivorRatio）以及晋升老年代对象的年龄（-XX:PretenureSizeThreshold）等参数，收集器会根据当前系统的运行情况自动调整</td> 
  </tr> 
  <tr> 
   <td>Serial Old</td> 
   <td>无</td> 
   <td>Serial Old是Serial的老年代版本，主要用于 Client 模式下的老生代收集，同时也是 CMS 在发生 Concurrent Mode Failure时的后备方案</td> 
  </tr> 
  <tr> 
   <td>Parallel Old</td> 
   <td>-XX:+UseParallelOldGC</td> 
   <td>开启后，使用Parallel Scavenge + Parallel Old的组合。Parallel Old是Parallel Scavenge的老年代版本，在注重吞吐量和 CPU 资源敏感的场合，可以优先考虑这个组合</td> 
  </tr> 
  <tr> 
   <td>CMS</td> 
   <td>-XX:+UseConcMarkSweepGC</td> 
   <td>开启后，使用ParNew + CMS的组合；Serial Old收集器将作为CMS收集器出现 Concurrent Mode Failure 失败后的后备收集器使用</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:CMSInitiatingOccupancyFraction=68</td> 
   <td>CMS 收集器在老年代空间被使用多少后触发垃圾收集，默认68%</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:+UseCMSCompactAtFullCollection</td> 
   <td>在完成垃圾收集后是否要进行一次内存碎片整理，默认开启</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:CMSFullGCsBeforeCompaction=0</td> 
   <td>在进行若干次Full GC后就进行一次内存碎片整理，默认0</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:+UseCMSInitiatingOccupancyOnly</td> 
   <td>允许使用占用值作为启动CMS收集器的唯一标准，一般和CMSFullGCsBeforeCompaction配合使用。如果开启，那么当CMSFullGCsBeforeCompaction达到阈值就开始GC，如果关闭，那么JVM仅在第一次使用CMSFullGCsBeforeCompaction的值，后续则自动调整，默认关闭。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:+CMSParallelRemarkEnabled</td> 
   <td>重新标记阶段并行执行，使用此参数可降低标记停顿，默认打开（仅适用于ParNewGC）</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:+CMSScavengeBeforeRemark</td> 
   <td>开启或关闭在CMS重新标记阶段之前的清除（YGC）尝试。新生代里一部分对象会作为GC Roots，让CMS在重新标记之前，做一次YGC，而YGC能够回收掉新生代里大多数对象，这样就可以减少GC Roots的开销。因此，打开此开关，可在一定程度上降低CMS重新标记阶段的扫描时间，当然，开启此开关后，YGC也会消耗一些时间。PS. 开启此开关并不保证在标记阶段前一定会进行清除操作，生产环境建议开启，默认关闭。</td> 
  </tr> 
  <tr> 
   <td>CMS-Precleaning</td> 
   <td>-XX:+CMSPrecleaningEnabled</td> 
   <td>是否启用并发预清理，默认开启</td> 
  </tr> 
  <tr> 
   <td>CMS-AbortablePreclean</td> 
   <td>-XX:CMSScheduleRemark<br>EdenSizeThreshold=2M</td> 
   <td>如果伊甸园的内存使用超过该值，才可能进入“并发可中止的预清理”这个阶段</td> 
  </tr> 
  <tr> 
   <td>CMS-AbortablePreclean</td> 
   <td>-XX:CMSMaxAbortablePrecleanLoops=0</td> 
   <td>“并发可终止的预清理阶段”的循环次数，默认0，表示不做限制</td> 
  </tr> 
  <tr> 
   <td>CMS-AbortablePreclean</td> 
   <td>-XX:+CMSMaxAbortablePrecleanTime=5000</td> 
   <td>“并发可终止的预清理”阶段持续的最大时间</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:+CMSClassUnloadingEnabled</td> 
   <td>使用CMS时，是否启用类卸载，默认开启</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:+ExplicitGCInvokesConcurrent</td> 
   <td>显示调用System.gc()会触发Full GC，会有Stop The World，开启此参数后，可让System.gc()触发的垃圾回收变成一次普通的CMS GC。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:+UseG1GC</td> 
   <td>使用G1收集器</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:G1HeapRegionSize=n</td> 
   <td>设置每个region的大小，该值为2的幂，范围为1MB到32MB，如不指定G1会根据堆的大小自动决定</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:MaxGCPauseMillis=200</td> 
   <td>设置最大停顿时间，默认值为200毫秒。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:G1NewSizePercent=5</td> 
   <td>设置年轻代占整个堆的最小百分比，默认值是5，这是个实验参数。需用-XX:+UnlockExperimentalVMOptions解锁试验参数后，才能使用该参数。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:G1MaxNewSizePercent=60</td> 
   <td>设置年轻代占整个堆的最大百分比，默认值是60，这是个实验参数。需用-XX:+UnlockExperimentalVMOptions解锁试验参数后，才能使用该参数。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:ParallelGCThreads=n</td> 
   <td>设置垃圾收集器在并行阶段使用的垃圾收集线程数，当逻辑处理器数量小于8时，n的值与逻辑处理器数量相同；如果逻辑处理器数量大于8个，则n的值大约为逻辑处理器数量的5/8，大多数情况下是这样，除了较大的SPARC系统，其中n的值约为逻辑处理器的5/16。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:ConcGCThreads=n</td> 
   <td>设置垃圾收集器并发阶段使用的线程数量，设置n大约为ParallelGCThreads的1/4。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:InitiatingHeapOccupancyPercent=45</td> 
   <td>老年代大小达到该阈值，就触发Mixed GC，默认值为45。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:G1MixedGCLiveThresholdPercent=85</td> 
   <td>Region中的对象，活跃度低于该阈值，才可能被包含在Mixed GC收集周期中，默认值为85，这是个实验参数。需用-XX:+UnlockExperimentalVMOptions解锁试验参数后，才能使用该参数。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:G1HeapWastePercent=5</td> 
   <td>设置浪费的堆内存百分比，当可回收百分比小于浪费百分比时，JVM就不会启动Mixed GC，从而避免昂贵的GC开销。此参数相当于用来设置允许垃圾对象占用内存的最大百分比。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:G1MixedGCCountTarget=8</td> 
   <td>设置在标记周期完成之后，最多执行多少次Mixed GC，默认值为8。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:G1OldCSetRegionThresholdPercent=10</td> 
   <td>设置在一次Mixed GC中被收集的老年代的比例上限，默认值是Java堆的10%，这是个实验参数。需用-XX:+UnlockExperimentalVMOptions解锁试验参数后，才能使用该参数。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:G1ReservePercent=10</td> 
   <td>设置预留空闲内存百分比，虚拟机会保证Java堆有这么多空间可用，从而防止对象晋升时无空间可用而失败，默认值为Java堆的10％。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:-G1PrintHeapRegions</td> 
   <td>输出Region被分配和回收的信息，默认false</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-XX:-G1PrintRegionLivenessInfo</td> 
   <td>在清理阶段的并发标记环节，输出堆中的所有Regions的活跃度信息，默认false</td> 
  </tr> 
  <tr> 
   <td>Shenandoah</td> 
   <td>-XX:+UseShenandoahGC</td> 
   <td>使用UseShenandoahGC，这是个实验参数，需用-XX:+UnlockExperimentalVMOptions解锁试验参数后，才能使用该参数；另外该参数只能在Open JDK中使用，Oracle JDK无法使用</td> 
  </tr> 
  <tr> 
   <td>ZGC</td> 
   <td>-XX:+UseZGC</td> 
   <td>使用ZGC，这是个实验参数，需用-XX:+UnlockExperimentalVMOptions解锁试验参数后，才能使用该参数；</td> 
  </tr> 
  <tr> 
   <td>Epsilon</td> 
   <td>-XX:+UseEpsilonGC</td> 
   <td>使用EpsilonGC，这是个实验参数，需用-XX:+UnlockExperimentalVMOptions解锁试验参数后，才能使用该参数；</td> 
  </tr> 
 </tbody> 
</table>

[JVM]: https://jiandansuifeng.blog.csdn.net/article/details/109379508
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70]: /images/20221119/7c6fbc61aac04b03b078b88255a7a81c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2021011510090787.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210115103424453.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210115103940412.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210115104312209.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/2021011510513554.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210115144952150.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210122161622597.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/2021012216324436.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20210122164752167.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/202101221701017.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20210122170704300.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20210122180111101.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20210122181425478.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0MzI2MDMwNDM0,size_16,color_FFFFFF,t_70