JVM学习一（JVM的内存结构和垃圾回收）

客官°小女子只卖身不卖艺 2023-06-30 08:49 10阅读 0赞

# JVM学习 #

#### 1.JVM的内存结构 ####

JVM的内存结构分为：程序计数器，虚拟机栈，本地方法栈，方法区，堆，虚拟机栈![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70]  
[**JVM运行时数据区**][JVM]

**1程序计数器**  
*定义*：Program Counter Register 程序计数器（寄存器）  
程序计数器（Program Counter Register）是一块较小的内存空间，它可以看作是当前线程所执行的  
字节码的行号指示器。  
作用：是记住下一条jvm指令的执行地址  
特点：是线程私有的 不会存在内存溢  
1.2作用：

0: getstatic     #20                 // PrintStream out = System.out;
     3: astore_1                          // --
     4: aload_1                           // out.println(1);
     5: iconst_1                          // --
     6: invokevirtual #26                 // --
     9: aload_1                           // out.println(2);
    10: iconst_2                          // --
    11: invokevirtual #26                 // --
    14: aload_1                           // out.println(3);
    15: iconst_3                          // --
    16: invokevirtual #26                 // --
    19: aload_1                           // out.println(4);
    20: iconst_4                          // --
    21: invokevirtual #26                 // --
    24: aload_1                           // out.println(5);
    25: iconst_5                          // --
    26: invokevirtual #26                 // --

**2虚拟机栈**  
2.1 定义  
Java Virtual Machine Stacks （Java 虚拟机栈）  
每个线程运行时所需要的内存，称为虚拟机栈  
每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法  
**Java虚拟机都  
会同步创建一个栈帧\[1\]（Stack Frame）用于存储局部变量表、操作数栈、动态连接、方法出口等信  
息**  
问题辨析

1.  垃圾回收是否涉及栈内存？
2.  栈内存分配越大越好吗？
3.  方法内的局部变量是否线程安全？  
    如果方法内局部变量没有逃离方法的作用访问，它是线程安全的  
    如果是局部变量引用了对象，并逃离方法的作用范围，需要考虑线程安全  
    2.2 栈内存溢出  
    栈帧过多导致栈内存溢出栈帧过大导致栈内存溢出  
    2.3 线程运行诊断  
    案例1： cpu 占用过多定位  
    用top定位哪个进程对cpu的占用过高  
    ps H -eo pid,tid,%cpu | grep 进程id （用ps命令进一步定位是哪个线程引起的cpu占用过高） jstack 进程id  
    可以根据线程id 找到有问题的线程，进一步定位到问题代码的源码行号  
    案例2：程序运行很长时间没有结果  
    **3 本地方法栈**  
    而本地方法栈则是为虚拟机使用到的本地（Native）  
    方法服务。

**4. 堆**  
4.1 定义  
Heap 堆  
通过 new 关键字，创建对象都会使用堆内存特点  
它是线程共享的，堆中对象都需要考虑线程安全的问题 有垃圾回收机制  
4.2 堆内存溢出  
4.3 堆内存诊断

1.  jps 工具  
    查看当前系统中有哪些 java 进程
2.  jmap 工具 查看堆内存占用情况 jmap - heap 进程id
3.  jconsole 工具  
    图形界面的，多功能的监测工具，可以连续监测  
    案例 垃圾回收后，内存占用仍然很高

**5. 方法区**  
组成  
![JDK1.6][]  
![JDK1.8][]  
5.3 方法区内存溢出  
1.8 以前会导致永久代内存溢出

/** * 演示永久代内存溢出 java.lang.OutOfMemoryError: PermGen space * -XX:MaxPermSize=8m */
    public class Demo1_8 extends ClassLoader { 
        public static void main(String[] args) { 
            int j = 0;
            try { 
                Demo1_8 test = new Demo1_8();
                for (int i = 0; i < 20000; i++, j++) { 
                    ClassWriter cw = new ClassWriter(0);
                    cw.visit(Opcodes.V1_6, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
                    byte[] code = cw.toByteArray();
                    test.defineClass("Class" + i, code, 0, code.length);
                }
            } finally { 
                System.out.println(j);
            }
        }
    }

1.8之后会导致元空间内存溢出

/** * 演示元空间内存溢出 java.lang.OutOfMemoryError: Metaspace * -XX:MaxMetaspaceSize=8m */
    public class Demo1_8 extends ClassLoader {  // 可以用来加载类的二进制字节码
        public static void main(String[] args) { 
            int j = 0;
            try { 
                Demo1_8 test = new Demo1_8();
                for (int i = 0; i < 10000; i++, j++) { 
                    // ClassWriter 作用是生成类的二进制字节码
                    ClassWriter cw = new ClassWriter(0);
                    // 版本号， public， 类名, 包名, 父类， 接口
                    cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
                    // 返回 byte[]
                    byte[] code = cw.toByteArray();
                    // 执行了类的加载
                    test.defineClass("Class" + i, code, 0, code.length); // Class 对象
                }
            } finally { 
                System.out.println(j);
            }
        }
    }

5.4 运行时常量池  
常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息  
运行时常量池，常量池是 \*.class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址  
5.5 StringTable 特性  
常量池中的字符串仅是符号，第一次用到时才变为对象利用串池的机制，来避免重复创建字符串对象  
字符串变量拼接的原理是 StringBuilder （1.8）字符串常量拼接的原理是编译期优化  
可以使用 intern 方法，主动将串池中还没有的字符串对象放入串池  
1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回  
1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份，放入串池， 会把串池中的对象返回  
6.直接内存  
6.1 定义  
Direct Memory  
常见于 NIO 操作时，用于数据缓冲区分配回收成本较高，但读写性能高不受 JVM 内存回收管理  
6.2 分配和回收原理  
使用了 Unsafe 对象完成直接内存的分配回收，并且回收需要主动调用 freeMemory 方法 ByteBuffer 的实现类内部，使用了 Cleaner （虚引用）来监测 ByteBuffer 对象，一旦  
ByteBuffer 对象被垃圾回收，那么就会由 ReferenceHandler 线程通过 Cleaner 的 clean 方法调用 freeMemory 来释放直接内存

# 垃圾回收 #

#### 如何判断对象可以回收 ####

1 引用计数法  
1.2 可达性分析算法  
Java 虚拟机中的垃圾回收器采用可达性分析来探索所有存活的对象  
扫描堆中的对象，看是否能够沿着 GC Root对象 为起点的引用链找到该对象，找不到，表示可以回收  
哪些对象可以作为 GC Root ?  
1.3 四种引用

1.  强引用  
    只有所有 GC Roots 对象都不通过【强引用】引用该对象，该对象才能被垃圾回收
2.  软引用（SoftReference）  
    仅有软引用引用该对象时，在垃圾回收后，内存仍不足时会再次出发垃圾回收，回收软引用对象  
    可以配合引用队列来释放软引用自身
3.  弱引用（WeakReference）  
    仅有弱引用引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用对象可以配合引用队列来释放弱引用自身
4.  虚引用（PhantomReference）  
    必须配合引用队列使用，主要配合 ByteBuffer 使用，被引用对象回收时，会将虚引用入队，由 Reference Handler 线程调用虚引用相关方法释放直接内存
5.  终结器引用（FinalReference）  
    无需手动编码，但其内部配合引用队列使用，在垃圾回收时，终结器引用入队（被引用对象暂时没有被回收），再由 Finalizer 线程通过终结器引用找到被引用对象并调用它的 finalize 方法，第二次 GC 时才能回收被引用对象

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

**1 标记清除**  
定义： Mark Sweep 速度较快  
缺点：会造成内存碎片  
**2. 标记整理**  
定义：Mark Compact 没有内存碎片  
缺点：速度慢  
**.3 复制**  
定义：Copy ●不会有内存碎片  
缺点：需要占用双倍内存空间  
**4.分代垃圾回收**  
对象首先分配在伊甸园区域  
新生代空间不足时，触发 minor gc，伊甸园和 from 存活的对象使用 copy 复制到 to 中，存活的对象年龄加 1并且交换 from to  
minor gc 会引发 stop the world，暂停其它用户的线程，等垃圾回收结束，用户线程才恢复运行当对象寿命超过阈值时，会晋升至老年代，最大寿命是15（4bit）  
当老年代空间不足，会先尝试触发 minor gc，如果之后空间仍不足，那么触发 full gc，STW(Stop the World)的时间更长  
**JVM的相关参数**

<table> 
 <thead> 
  <tr> 
   <th>说明</th> 
   <th>参数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>堆初始大小</td> 
   <td>-Xms</td> 
  </tr> 
  <tr> 
   <td>堆最大大小</td> 
   <td>-Xmx 或 -XX:MaxHeapSize=size</td> 
  </tr> 
  <tr> 
   <td>新生代大小</td> 
   <td>-Xmn 或 (-XX:NewSize=size + -XX:MaxNewSize=size )</td> 
  </tr> 
  <tr> 
   <td>幸存区比例（动态）</td> 
   <td>-XX:InitialSurvivorRatio=ratio 和 -XX:+UseAdaptiveSizePolicy</td> 
  </tr> 
  <tr> 
   <td>幸存区比例</td> 
   <td>-XX:SurvivorRatio=ratio</td> 
  </tr> 
  <tr> 
   <td>晋升阈值</td> 
   <td>-XX:MaxTenuringThreshold=threshold</td> 
  </tr> 
  <tr> 
   <td>晋升详情</td> 
   <td>-XX:+PrintTenuringDistribution</td> 
  </tr> 
  <tr> 
   <td>GC详情</td> 
   <td>-XX:+PrintGCDetails -verbose:gc</td> 
  </tr> 
  <tr> 
   <td>FullGC 前先 MinorGC</td> 
   <td>-XX:+ScavengeBeforeFullG</td> 
  </tr> 
 </tbody> 
</table>

#### 垃圾回收器 ####

1.  串行  
    单线程堆内存较小，适合个人电脑
2.  吞吐量优先  
    多线程堆内存较大，多核 cpu 让单位时间内，STW 的时间最短 0.2 0.2 = 0.4，垃圾回收时间占比最低，这样就称吞吐量高
3.  响应时间优先多线程  
    堆内存较大，多核 cpu  
    尽可能让单次 STW 的时间最短 0.1 0.1 0.1 0.1 0.1 = 0.5  
    .**1 串行**  
    \-XX:+UseSerialGC = Serial + SerialOld  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 1]  
    **2.吞吐量优先**

-XX:+UseParallelGC ~ -XX:+UseParallelOldGC
    -XX:GCTimeRatio=ratio
    -XX:MaxGCPauseMillis=ms
    -XX:ParallelGCThreads=n

![在这里插入图片描述][20200116110019192.png]  
**3响应时间优先**

-XX:+UseConcMarkSweepGC ~ -XX:+UseParNewGC ~ SerialOld
    -XX:ParallelGCThreads=n ~ -XX:ConcGCThreads=threads
    -XX:CMSInitiatingOccupancyFraction=percent
    -XX:+CMSScavengeBeforeRemark

![在这里插入图片描述][2020011611014960.png]  
**4 G1**  
定义：Garbage First  
2004 论文发布  
2009 JDK 6u14 体验  
2012 JDK 7u4 官方支持 2017 JDK 9 默认  
适用场景  
同时注重吞吐量（Throughput）和低延迟（Low latency），默认的暂停目标是 200 ms 超大堆内存，会将堆划分为多个大小相等的 Region 整体上是标记+整理算法，两个区域之间是复制算法相关 JVM 参数  
\-XX:+UseG1GC  
\-XX:G1HeapRegionSize=size  
\-XX:MaxGCPauseMillis=time

1.  G1 垃圾回收阶段  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 2]
2.  Young Collection  
    会 STW  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 3]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 4]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 5]
3.  Young Collection + CM  
    在 Young GC 时会进行 GC Root 的初始标记  
    老年代占用堆空间比例达到阈值时，进行并发标记（不会 STW），由下面的 JVM 参数决定  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 6]
4.  Mixed Collection  
    会对 E、S、O 进行全面垃圾回收最终标记（Remark）会 STW 拷贝存活（Evacuation）会 STW  
    \-XX:MaxGCPauseMillis=ms  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 7]

### 5) Full GC ###

1.SerialGC(串行GC)  
新生代内存不足发生的垃圾收集 - minor gc  
老年代内存不足发生的垃圾收集 - full gc  
2.ParallelGC(并行GC)  
新生代内存不足发生的垃圾收集 - minor gc  
老年代内存不足发生的垃圾收集 - full gc  
3.CMS(并发标记-清除)  
新生代内存不足发生的垃圾收集 - minor gc  
老年代内存不足（看情况）  
4.G1(垃圾优先算法)  
新生代内存不足发生的垃圾收集 - minor gc  
老年代内存不足（看情况）  
当老年代占堆内存的达到45%，发送minor gc  
当产生的垃圾的速度比回收速度快，并发收集失败，  
转换成串行的垃圾回收，就发生–full gc  
[更多][Link 1]

## 6) Young Collection 跨代引用 ##

新生代回收的跨代引用（老年代引用新生代）问题  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 8]  
卡表与 Remembered Set  
在引用变更时通过 post-write barrier + dirty card queue  
concurrent refinement threads 更新 Remembered Set  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 9]  
7) Remark  
pre-write barrier + satb\_mark\_queue  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 10]  
8) JDK 8u20 字符串去重  
优点：节省大量内存  
缺点：略微多占用了 cpu 时间，新生代回收时间略微增加  
\-XX:+UseStringDeduplication  
![在这里插入图片描述][20200116111334586.png]  
将所有新分配的字符串放入一个队列  
当新生代回收时，G1并发检查是否有字符串重复  
如果它们值一样，让它们引用同一个 char\[\]  
注意，与 String.intern() 不一样  
String.intern() 关注的是字符串对象  
而字符串去重关注的是 char\[\]  
在 JVM 内部，使用了不同的字符串表  
9) JDK 8u40 并发标记类卸载  
所有对象都经过并发标记后，就能知道哪些类不再被使用，当一个类加载器的所有类都不再使用，则卸  
载它所加载的所有类 -XX:+ClassUnloadingWithConcurrentMark 默认启用  
10) JDK 8u60 回收巨型对象  
一个对象大于 region 的一半时，称之为巨型对象  
G1 不会对巨型对象进行拷贝  
回收时被优先考虑  
G1 会跟踪老年代所有 incoming 引用，这样老年代 incoming 引用为0 的巨型对象就可以在新生  
代垃圾回收时处理掉  
11) JDK 9 并发标记起始时间的调整  
并发标记必须在堆空间占满前完成，否则退化为 FullGC  
JDK 9 之前需要使用 -XX:InitiatingHeapOccupancyPercent  
JDK 9 可以动态调整  
\-XX:InitiatingHeapOccupancyPercent 用来设置初始值  
进行数据采样并动态调整  
总会添加一个安全的空档空间  
12) JDK 9 更高效的回收  
250+增强  
180+bug修复  
https://docs.oracle.com/en/java/javase/12/gctuning  
**12.G1的运行示意图**  
![在这里插入图片描述][20201113092717491.png_pic_center]  
**CMS和G1的比较**  
相比CMS，G1的优点有很多，暂且不论可以指定最大停顿时间、分Region的内存布局、按收益动态确定回收集这些创新性设计带来的红利，单从最传统的算法理论上看，G1也更有发展潜力。与CMS的“标记-清除”算法不同，G1从整体来看是基于“标记-整理”算法实现的收集器，但从局部（两个Region之间）上看又是基于“标记-复制”算法实现，无论如何，这两种算法都意味着G1运作期间不会产生内存空间碎片，垃圾收集完成之后能提供规整的可用内存。这种特性有利于程序长时间运行，在程序为大对象分配内存时不容易因无法找到连续内存空间而提前触发下一次收集

上的优缺点对比仅仅是针对G1和CMS两款垃圾收集器单独某方面的实现细节的定性分析，通常我们说哪款收集器要更好、要好上多少，往往是针对具体场景才能做的定量比较。按照笔者的实践经验，目前在小内存应用上CMS的表现大概率仍然要会优于G1，而在大内存应用上G1则大多能发挥其优势，这个优劣势的Java堆容量平衡点通常在6GB至8GB之间，当然，以上这些也仅是经验之谈，不同应用需要量体裁衣地实际测试才能得出最合适的结论，随着HotSpot的开发者对G1的不断优化，也会让对比结果继续向G1倾斜

## 调优 ##

##### 5.1 调优领域 #####

内存  
锁竞争  
cpu 占用  
io

##### 确定目标 #####

【低延迟】还是【高吞吐量】，选择合适的回收器  
CMS，G1，ZGC  
ParallelGC  
Zing

##### 最快的 GC #####

答案是不发生 GC  
查看 FullGC 前后的内存占用，考虑下面几个问题  
数据是不是太多？  
resultSet = statement.executeQuery(“select \* from 大表 limit n”)  
数据表示是否太臃肿？  
对象图  
对象大小 16 Integer 24 int 4  
是否存在内存泄漏？  
static Map map =  
软  
弱  
第三方缓存实现

##### 新生代调优 #####

新生代的特点  
所有的 new 操作的内存分配非常廉价  
TLAB thread-local allocation buffer  
死亡对象的回收代价是零  
大部分对象用过即死  
Minor GC 的时间远远低于 Full GC  
越大越好吗？  
\-Xmn Sets the initial and maximum size (in bytes) of the heap for the young generation (nursery).  
GC is performed in this region more often than in other regions. If the size for the young  
generation is too small, then a lot of minor garbage collections are performed. If the size is too  
large, then only full garbage collections are performed, which can take a long time to complete.  
Oracle recommends that you keep the size for the young generation greater than 25% and less  
than 50% of the overall heap size.  
新生代能容纳所有【并发量 \* (请求-响应)】的数据  
幸存区大到能保留【当前活跃对象+需要晋升对象】  
晋升阈值配置得当，让长时间存活对象尽快晋升  
\-XX:MaxTenuringThreshold=threshold  
\-XX:+PrintTenuringDistribution  
Desired survivor size 48286924 bytes, new threshold 10 (max 10)

*  age 1: 28992024 bytes, 28992024 total
 *  age 2: 1366864 bytes, 30358888 total
 *  age 3: 1425912 bytes, 31784800 total

##### 老年代调优 #####

以 CMS 为例  
CMS 的老年代内存越大越好  
先尝试不做调优，如果没有 Full GC 那么已经…，否则先尝试调优新生代  
观察发生 Full GC 时老年代内存占用，将老年代内存预设调大 1/4 ~ 1/3  
\-XX:CMSInitiatingOccupancyFraction=percent

##### 案例 #####

案例1 Full GC 和 Minor GC频繁  
案例2 请求高峰期发生 Full GC，单次暂停时间特别长 （CMS）  
案例3 老年代充裕情况下，发生 Full GC （CMS jdk1.7）

#### CMS ####

[***CMS垃圾回收器详解***][CMS]

#### G1 ####

[美团的Java Hotspot G1 GC的一些关键技术][Java Hotspot G1 GC]

[CMS收集器和G1收集器][CMS_G1]

#### ZGC ####

[新一代垃圾回收器ZGC的探索与实践][ZGC]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200116101532326.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0,size_16,color_FFFFFF,t_70
[JVM]: https://juejin.im/post/5bc4b71cf265da0ab3317729
[JDK1.6]: https://img-blog.csdnimg.cn/20200116102753293.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0,size_16,color_FFFFFF,t_70
[JDK1.8]: https://img-blog.csdnimg.cn/20200116102825208.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200116105700337.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0,size_16,color_FFFFFF,t_70
[20200116110019192.png]: https://img-blog.csdnimg.cn/20200116110019192.png
[2020011611014960.png]: https://img-blog.csdnimg.cn/2020011611014960.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200116110459274.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200116110549156.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200116110627375.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200116110641151.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/2020011611082371.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/2020011611084145.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0,size_16,color_FFFFFF,t_70
[Link 1]: https://blog.csdn.net/renfufei/article/details/54885190
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200116111027237.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200116111058684.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200116111154303.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMTk4MDA0,size_16,color_FFFFFF,t_70
[20200116111334586.png]: https://img-blog.csdnimg.cn/20200116111334586.png
[20201113092717491.png_pic_center]: https://img-blog.csdnimg.cn/20201113092717491.png#pic_center
[CMS]: https://blog.csdn.net/zqz_zqz/article/details/70568819
[Java Hotspot G1 GC]: https://tech.meituan.com/2016/09/23/g1.html
[CMS_G1]: https://www.cnblogs.com/aspirant/p/8663897.html
[ZGC]: https://tech.meituan.com/2020/08/06/new-zgc-practice-in-meituan.html