jvm 图灵

梦里梦外; 2022-11-19 07:56 307阅读 0赞

# 1.类加载机制深度解析 #

**通过Java命令执行代码的大体流程如下：**

![0][]  
**其中loadClass的类加载过程有如下几步：**

**加载 >> 验证 >> 准备 >> 解析 >> 初始化 >>** 使用 >> 卸载

*  加载：在硬盘上查找并通过IO读入字节码文件，使用到类时才会加载，例如调用类的main()方法，new对象等等，在加载阶段会在内存中生成一个**代表这个类的java.lang.Class对象**，作为方法区这个类的各种数据的访问入口
 *  验证：校验字节码文件的正确性
 *  准备：给类的静态变量分配内存，并赋予默认值(例如 int类型变量赋值为0)
 *  解析：将**符号引用**替换为直接引用（将符号引用转换成对应的内存地址），该阶段会把一些静态方法(符号引用，比如main()方法)替换为指向数据所存内存的指针或句柄等(直接引用)，这是所谓的**静态链接**过程(类加载期间完成)，**动态链接**是在程序运行期间完成的将符号引用替换为直接引用，下节课会讲到动态链接
 *  **初始化**：对类的静态变量初始化为代码中指定的值，执行静态代码块
 *  ![0][0 1]  
    类被加载到方法区(java 叫元空间)中后主要包含 **常量+静态变量+类信息**等信息。

**类加载器的引用**：这个类到类加载器实例的引用

**对应class实例的引用**：类加载器在加载类信息放到方法区中后，会创建一个对应的Class 类型的对象实例放到堆(Heap)中, 作为开发人员访问方法区中类定义的入口和切入点。

\*\*注意，\*\*主类在运行过程中如果使用到其它类，会逐步加载这些类。

jar包或war包里的类不是一次性全部加载的，是使用到时才加载。

public class TestDynamicLoad { 
    
        static { 
            System.out.println("*************load TestDynamicLoad************");
        }
    
        public static void main(String[] args) { 
            new A();
            System.out.println("*************load test************");
            B b = null;  //B不会加载，除非这里执行 new B()
        }
    }
    
    class A { 
        static { 
            System.out.println("*************load A************");
        }
    
        public A() { 
            System.out.println("*************initial A************");
        }
    }
    
    class B { 
        static { 
            System.out.println("*************load B************");
        }
    
        public B() { 
            System.out.println("*************initial B************");
        }
    }
    
    运行结果：
    *************load TestDynamicLoad************
    *************load A************
    *************initial A************
    *************load test************

**类加载器和双亲委派机制**

上面的类加载过程主要是通过类加载器来实现的，Java里有如下几种类加载器

*  引导类加载器：负责加载支撑JVM运行的位于JRE的lib目录下的核心类库，比如rt.jar、charsets.jar等
 *  扩展类加载器：负责加载支撑JVM运行的位于JRE的lib目录下的ext扩展目录中的JAR类包
 *  应用程序类加载器：负责加载ClassPath路径下的类包，主要就是加载你自己写的那些类
 *  自定义加载器：负责加载用户自定义路径下的类包

**双亲委派机制**

JVM类加载器是有亲子层级结构的，如下图

![0][0 2]

这里类加载其实就有一个**双亲委派机制**，加载某个类时会先委托父加载器寻找目标类，找不到再委托上层父加载器加载，如果所有父加载器在自己的加载类路径下都找不到目标类，则在自己的类加载路径中查找并载入目标类。

比如我们的Math类，最先会找应用程序类加载器加载，应用程序类加载器会先委托扩展类加载器加载，扩展类加载器再委托引导类加载器，顶层引导类加载器在自己的类加载路径里找了半天没找到Math类，则向下退回加载Math类的请求，扩展类加载器收到回复就自己加载，在自己的类加载路径里找了半天也没找到Math类，又向下退回Math类的加载请求给应用程序类加载器，应用程序类加载器于是在自己的类加载路径里找Math类，结果找到了就自己加载了。。

**双亲委派机制说简单点就是，先找父亲加载，不行再由儿子自己加载**

**为什么要设计双亲委派机制？**

*  沙箱安全机制：自己写的java.lang.String.class类不会被加载，这样便可以防止核心API库被随意篡改
 *  避免类的重复加载：当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次，保证\*\*被加载类的唯一性

# 2.JVM整体结构深度解析 #

**JDK体系结构** ![0][0 3]

**Java语言的跨平台特性**  
 ![0][0 4]

**JVM整体结构及JVM内存模型**

原空间放的是常量和静态变量的引用地址，之变量对象实际是存在堆里面的。

元空间大小为20M满了会发生full GC，如果这次full gc 在元空间回收的内存很少，说明元空间垃圾很少，这种情况下，会扩容元空间

1.本地方法栈（Native Method Stacks）与虚拟机栈所发挥的作用是非常相似的，

2.其区别不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则是为虚拟机使用到的Native方法服务。  
![0][0 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70]

**JVM内存参数设置**

![0][0 6]

Spring Boot程序的JVM参数设置格式(Tomcat启动直接加在bin目录下catalina.sh文件里)：

java -Xms2048M -Xmx2048M -Xmn1024M -Xss512K -XX:MetaspaceSize=256M -XX:MaxMetaspaceSize=256M -jar microservice-eureka-server.jar

\-Xss：每个线程的栈大小，默认1M，如栈(线程1)的大小为1M, 栈(线程2)的大小为1M

\-Xms：初始堆大小，默认物理内存的1/64

\-Xmx：最大堆大小，默认物理内存的1/4

\-Xmn：新生代大小

\-XX:NewSize：设置新生代初始大小

\-XX:NewRatio：默认2，默认2表示新生代占年老代的1/2，及年轻代占整个堆内存的1/3。

\-XX:SurvivorRatio：默认8表示一个survivor区占用1/8的Eden内存，即1/10的新生代内存。

关于元空间的JVM参数有两个：-XX:MetaspaceSize=N和 -XX:MaxMetaspaceSize=N

**-XX：MaxMetaspaceSize**： 设置元空间最大值， 默认是-1， 即不限制， 或者说只受限于本地内存大小。

**-XX：MetaspaceSize**： 指定元空间触发Fullgc的初始阈值(元空间无固定初始大小)， 以字节为单位，默认是21M，达到该值就会触发full gc进行类型卸载， 同时收集器会对该值进行调整： 如果释放了大量的空间， 就适当降低该值； 如果释放了很少的空间， 那么在不超过-XX：MaxMetaspaceSize（如果设置了的话） 的情况下， 适当提高该值。这个跟早期jdk版本的\*\*-XX:PermSize\*\*参数意思不一样，-**XX:PermSize**代表永久代的初始容量。

由于调整元空间的大小需要Full GC，这是非常昂贵的操作，如果应用在启动的时候发生大量Full GC，通常都是由于永久代或元空间发生了大小调整，基于这种情况，一般建议在JVM参数中将MetaspaceSize和MaxMetaspaceSize设置成一样的值，并设置得比初始值要大，对于8G物理内存的机器来说，一般我会将这两个值都设置为256M。

**StackOverflowError**栈溢出示例：  
无限递归

// JVM设置 -Xss128k(默认1M)
    public class StackOverflowTest { 
        
        static int count = 0;
        
        static void redo() { 
            count++;
            redo();
        }
    
        public static void main(String[] args) { 
            try { 
                redo();
            } catch (Throwable t) { 
                t.printStackTrace();
                System.out.println(count);
            }
        }
    }
    
    运行结果：
    java.lang.StackOverflowError
    	at com.tuling.jvm.StackOverflowTest.redo(StackOverflowTest.java:12)
    	at com.tuling.jvm.StackOverflowTest.redo(StackOverflowTest.java:13)
    	at com.tuling.jvm.StackOverflowTest.redo(StackOverflowTest.java:13)
       ......

**结论：**

\-Xss设置越小count值越小及递归越浅，说明一个线程栈里能分配的栈帧就越少，但是对JVM整体来说能开启的线程数会更多

**JVM内存参数大小该如何设置？**

JVM参数大小设置并没有固定标准，需要根据实际项目情况分析，给大家举个例子

**日均百万级订单交易系统如何设置JVM参数**

![0][0 7]

\*\*结论：\*\***通过上面这些内容介绍，大家应该对JVM优化有些概念了，就是尽可能让对象都在新生代里分配和回收，尽量别让太多对象频繁进入老年代，避免频繁对老年代进行垃圾回收，同时给系统充足的内存大小，避免新生代频繁的进行垃圾回收。**

# 3.JVM对象创建与内存分配机制深度剖析 #

对象的创建\*\*

对象创建的主要流程:

![0][0 8]

**1.类加载检查**

虚拟机遇到一条new指令时，首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有，那必须先执行相应的类加载过程。

new指令对应到语言层面上讲是，new关键词、对象克隆、对象序列化等。

**2.分配内存**

在类加载检查通过后，接下来虚拟机将为新生对象分配内存。对象所需内存的大小在类 加载完成后便可完全确定，为对象分配空间的任务等同于把 一块确定大小的内存从Java堆中划分出来。

**解决并发问题的方法：**

*  CAS（compare and swap）

虚拟机采用**CAS配上失败重试**的方式保证更新操作的原子性来对分配内存空间的动作进行同步处理。

**3.初始化零值**

内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零值（不包括对象头）， 如果使用TLAB，这一工作过程也可以提前至TLAB分配时进行。这一步操作保证了对象的实例字段在Java代码中可以不赋初始值就直接使用，程序能访问到这些字段的数据类型所对应的零值。

**4.设置对象头**

初始化零值之后，虚拟机要对对象进行必要的设置，例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象的对象头Object Header之中。  
**5.执行方法**  
执行方法，即对象按照程序员的意愿进行初始化。对应到语言层面上讲，就是为属性赋值（注意，这与上面的赋零值不同，这是由程序员赋的值），和执行构造方法。

**对象栈上分配**

我们通过JVM内存分配可以知道JAVA中的对象都是在堆上进行分配，当对象没有被引用的时候，需要依靠GC进行回收内存，如果对象数量较多的时候，会给GC带来较大压力，也间接影响了应用的性能。为了减少临时对象在堆内分配的数量，JVM通过**逃逸分析**确定该对象不会被外部访问。如果不会逃逸可以将该对象在**栈上分配**内存，这样该对象所占用的内存空间就可以随栈帧出栈而销毁，就减轻了垃圾回收的压力。

**对象逃逸分析**：就是分析对象动态作用域，当一个对象在方法中被定义后，它可能被外部方法所引用，例如作为调用参数传递到其他地方中。

JVM对于这种情况可以通过开启逃逸分析参数(-XX:+DoEscapeAnalysis)来优化对象内存分配位置，使其通过**标量替换**优先分配在栈上(**栈上分配**)，**JDK7之后默认开启逃逸分析**，如果要关闭使用参数(-XX:-DoEscapeAnalysis)

对象在Eden区分配\*\*

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

在测试之前我们先来看看 **Minor GC和Full GC 有什么不同呢？**

*  **Minor GC/Young GC**：指发生新生代的的垃圾收集动作，Minor GC非常频繁，回收速度一般也比较快。
 *  **Major GC/Full GC**：一般会回收老年代 ，年轻代，方法区的垃圾，Major GC的速度一般会比Minor GC的慢10倍以上。

**Eden与Survivor区默认8:1:1**

大量的对象被分配在eden区，eden区满了后会触发minor gc，可能会有99%以上的对象成为垃圾被回收掉，剩余存活的对象会被挪到为空的那块survivor区，下一次eden区满了后又会触发minor gc，把eden区和survivor区垃圾对象回收，把剩余存活的对象一次性挪动到另外一块为空的survivor区，因为新生代的对象都是朝生夕死的，存活时间很短，所以JVM默认的8:1:1的比例是很合适的，**让eden区尽量的大，survivor区够用即可，**

JVM默认有这个参数-XX:+UseAdaptiveSizePolicy(默认开启)，会导致这个8:1:1比例自动变化，如果不想这个比例有变化可以设置参数-XX:-UseAdaptiveSizePolicy

大对象直接进入老年代\*\*

大对象就是需要大量连续内存空间的对象（比如：字符串、数组）。JVM参数 -XX:PretenureSizeThreshold 可以设置大对象的大小，如果对象超过设置大小会直接进入老年代，不会进入年轻代，这个参数只在 Serial 和ParNew两个收集器下有效。

比如设置JVM参数：-XX:PretenureSizeThreshold=1000000 (单位是字节) -XX:+UseSerialGC ，再执行下上面的第一个程序会发现大对象直接进了老年代

**为什么要这样呢？**

为了避免为大对象分配内存时的复制操作而降低效率。

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

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

如果对象在 Eden 出生并经过第一次 Minor GC 后仍然能够存活，并且能被 Survivor 容纳的话，将被移动到 Survivor 空间中，并将对象年龄设为1。对象在 Survivor 中每熬过一次 MinorGC，年龄就增加1岁，当它的年龄增加到一定程度（默认为15岁，CMS收集器默认6岁，不同的垃圾收集器会略微有点不同），就会被晋升到老年代中。对象晋升到老年代的年龄阈值，可以通过参数 **-XX:MaxTenuringThreshold** 来设置。

**对象动态年龄判断**

当前放对象的Survivor区域里(其中一块区域，放对象的那块s区)，一批对象的总大小大于这块Survivor区域内存大小的50%(-XX:TargetSurvivorRatio可以指定)，那么此时**大于等于**这批对象年龄最大值的对象，就可以直接进入老年代了，例如Survivor区域里现在有一批对象，年龄1+年龄2+年龄n的多个年龄对象总和超过了Survivor区域的50%，此时就会把年龄n(含)以上的对象都放入老年代。这个规则其实是希望那些可能是长期存活的对象，尽早进入老年代。**对象动态年龄判断机制一般是在minor gc之后触发的。**

**老年代空间分配担保机制**

年轻代每次**minor gc**之前JVM都会计算下老年代**剩余可用空间**

如果这个可用空间小于年轻代里现有的所有对象大小之和(**包括垃圾对象**)

就会看一个“-XX:-HandlePromotionFailure”(jdk1.8默认就设置了)的参数是否设置了

如果有这个参数，就会看看老年代的可用内存大小，是否大于之前每一次minor gc后进入老年代的对象的**平均大小**。

如果上一步结果是小于或者之前说的参数没有设置，那么就会触发一次Full gc，对老年代和年轻代一起回收一次垃圾，如果回收完还是没有足够空间存放新的对象就会发生"OOM"

当然，如果minor gc之后剩余存活的需要挪动到老年代的对象大小还是大于老年代可用空间，那么也会触发full gc，full gc完之后如果还是没有空间放minor gc之后的存活对象，则也会发生“OOM”

![0][0 9]

**对象内存回收**

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

**引用计数法**

给对象中添加一个引用计数器，每当有一个地方引用它，计数器就加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; \} \}

**可达性分析算法**

将\*\*“GC Roots”\*\* 对象作为起点，从这些节点开始向下搜索引用的对象，找到的对象都标记为**非垃圾对象**，其余未标记的对象都是垃圾对象

**GC Roots**根节点：线程栈的本地变量、静态变量、本地方法栈的变量等等

![0][0 10]

**常见引用类型**

java的引用类型一般分为四种：**强引用**、**软引用**、弱引用、虚引用

**强引用**：普通的变量引用

public static User user = new User();

**软引用**：将对象用SoftReference软引用类型的对象包裹，正常情况不会被回收，但是GC做完后发现释放不出空间存放新的对象，则会把这些软引用的对象回收掉。**软引用可用来实现内存敏感的高速缓存。**

public static SoftReference user = new SoftReference(new User());

软引用在实际中有重要的应用，例如浏览器的后退按钮。按后退时，这个后退时显示的网页内容是重新进行请求还是从缓存中取出呢？这就要看具体的实现策略了。

（1）如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建

（2）如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出

**弱引用**：将对象用WeakReference软引用类型的对象包裹，弱引用跟没引用差不多，**GC会直接回收掉**，很少用

public static WeakReference user = new WeakReference(new User());

\*\*虚引用：\*\*虚引用也称为幽灵引用或者幻影引用，它是最弱的一种引用关系，几乎不用

\*\*finalize()方法最终判定对象是否存活

finalize()方法最终判定对象是否存活\*\*

即使在可达性分析算法中不可达的对象，也并非是“非死不可”的，这时候它们暂时处于“缓刑”阶段，要真正宣告一个对象死亡，至少要经历再次标记过程。

**标记的前提是对象在进行可达性分析后发现没有与GC Roots相连接的引用链。**

**1. 第一次标记并进行一次筛选。**

筛选的条件是此对象是否有必要执行finalize()方法。

当对象没有覆盖finalize方法，对象将直接被回收。

**2. 第二次标记**

如果这个对象覆盖了finalize方法，finalize方法是对象脱逃死亡命运的最后一次机会，如果对象要在finalize()中成功拯救自己，只要重新与引用链上的任何的一个对象建立关联即可，譬如把自己赋值给某个类变量或对象的成员变量，那在第二次标记时它将移除出“即将回收”的集合。如果对象这时候还没逃脱，那基本上它就真的被回收了。

注意：一个对象的finalize()方法只会被执行一次，也就是说通过调用finalize方法自我救命的机会就一次。

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

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

类需要同时满足下面3个条件才能算是 **“无用的类”** ：

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

# 4.垃圾回收算法+垃圾回收器 #

## 垃圾回收算法 ##

垃圾回收算法  
标记-复制算法  
标记-清除算法  
标记-整理算法

**如果说收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。**  
![0][0 11]

## Parallel收集器 ##

1.2 Parallel Scavenge收集器(**-XX:+UseParallelGC(年轻代),-XX:+UseParallelOldGC(老年代)**)\*\*

**Parallel**收集器其实**就是Serial收集器的多线程版本**，除了使用多线程进行垃圾收集外，其余行为（控制参数、收集算法、回收策略等等）和Serial收集器类似。默认的收集线程数跟cpu核数相同，当然也可以用参数(-XX:ParallelGCThreads)指定收集线程数，但是一般不推荐修改。

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

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

![0][0 12]

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

## CMS收集器 ##

**CMS收集器用于老年代**  
**CMS收集器年轻代是用标记+复制算法，老年代使用标记清除+算法(产生垃圾碎片)  
G1收集器年轻代是用标记+复制算法，老年代使用标记+复制算法**

1.4 CMS收集器(\*\*\*\*-XX:+UseConcMarkSweepGC(old))\*\*

**CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。它非常符合在注重用户体验的应用上使用，它是HotSpot虚拟机第一款真正意义上的并发收集器，它第一次实现了让垃圾收集线程与用户线程（基本上）同时工作。**

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

*  **初始标记：** 暂停所有的其他线程(STW)，并记录下gc roots**直接能引用的对象**，**速度很快**。
 *  **并发标记：** 并发标记阶段就是从GC Roots的直接关联对象开始遍历整个对象图的过程， 这个过程耗时较长但是不需要停顿用户线程， 可以与垃圾收集线程一起并发运行。因为用户程序继续运行，可能会有导致已经标记过的对象状态发生改变。并发标记阶段时间最长大概占整个垃圾收集过程时间的80%，但是是并发的用户感知。
 *  **重新标记：** 重新标记阶段就是为了修正并发标记期间因为用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，**这个阶段的停顿时间一般会比初始标记阶段的时间稍长，远远比并发标记阶段时间短。主要用到三色标记里的\*\*\*\*增量更新算法(见下面详解)做重新标记。**
 *  **并发清理：** 开启用户线程，同时GC线程开始对未标记的区域做清扫。这个阶段如果有新增对象会被标记为黑色不做任何处理(见下面三色标记算法详解)。
 *  \*\*并发重置：\*\*重置本次GC过程中的标记数据。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 1]

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

*  对CPU资源敏感（会和服务抢资源）；
 *  无法处理**浮动垃圾**(在并发标记和并发清理阶段又产生新的垃圾，这种浮动垃圾只能等到下一次gc再清理了)；
 *  它使用的回收算法-**“标记-清除”算法**会导致收集结束时会有**大量空间碎片**产生，当然通过参数-XX:+UseCMSCompactAtFullCollection可以让jvm在执行完标记清除后再做整理
 *  由于gc过程和用户线程并发执行，带来了执行过程中的不确定性，会存在上一次垃圾回收还没执行完，然后垃圾回收又被触发的情况，**特别是在并发标记和并发清理阶段会出现**，一边回收，系统一边运行，也许没回收完用户线程又往老年代丢大对象就再次触发full gc，也就是"**concurrent mode failure**"，**此时会进入stop the world，用serial old垃圾收集器来回收**

**CMS的相关核心参数**

1.  \-XX:+UseConcMarkSweepGC：启用cms
2.  \-XX:ConcGCThreads：并发的GC线程数
3.  \-XX:+UseCMSCompactAtFullCollection：FullGC之后做压缩整理（减少碎片）
4.  \-XX:CMSFullGCsBeforeCompaction：多少次FullGC之后压缩一次，默认是0，代表每次FullGC后都会压缩一次
5.  \-XX:CMSInitiatingOccupancyFraction: 当老年代使用达到该比例时会触发FullGC（默认是92，这是百分比）
6.  \-XX:+UseCMSInitiatingOccupancyOnly：只使用设定的回收阈值(-XX:CMSInitiatingOccupancyFraction设定的值)，如果不指定，JVM仅在第一次使用设定值，后续则会自动调整
7.  \-XX:+CMSScavengeBeforeRemark：在CMS GC前启动一次minor gc，降低CMS GC标记阶段\*\*(**也会对年轻代一起做标记，如果在minor gc就干掉了很多对垃圾对象，标记阶段就会减少一些标记时间**)\*\*时的开销，一般CMS的GC耗时 80%都在标记阶段
8.  \-XX:+CMSParallellnitialMarkEnabled：表示在初始标记的时候多线程执行，缩短STW
9.  \-XX:+CMSParallelRemarkEnabled：在重新标记的时候多线程执行，缩短STW;

## G1收集器(-XX:+UseG1GC) ##

**G1垃圾收集器用于年轻代+老年代**  
**G1收集器年轻代是用标记+复制算法，老年代使用标记+复制算法  
CMS收集器年轻代是用标记+复制算法，老年代使用标记清除+算法(产生垃圾碎片)**

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

![0][0 13]  
**G1逻辑上保留了年轻代和老年代的概念，但不再是物理隔阂了，它们都是（可以不连续）Region的集合。**

![0][0 14]

G1将Java堆划分为多个大小相等的独立区域（**Region**），JVM目标是不超过2048个Region(JVM源码里TARGET\_REGION\_NUMBER 定义)，实际可以超过该值，但是不推荐。

一般Region大小等于堆大小除以2048，比如堆大小为4096M，则Region大小为2M，当然也可以用参数"-XX:G1HeapRegionSize"手动指定Region大小，但是推荐默认的计算方式。

G1保留了年轻代和老年代的概念，但不再是物理隔阂了，它们都是（可以不连续）Region的集合。

默认年轻代对堆内存的占比是5%，如果堆大小为4096M，那么年轻代占据200MB左右的内存，对应大概是100个Region，可以通过“-XX:G1NewSizePercent”设置新生代初始占比，在系统运行中，JVM会不停的给年轻代增加更多的Region，但是最多新生代的占比不会超过60%，可以通过“-XX:G1MaxNewSizePercent”调整。年轻代中的Eden和Survivor对应的region也跟之前一样，默认8:1:1，假设年轻代现在有1000个region，eden区对应800个，s0对应100个，s1对应100个。

一个Region可能之前是年轻代，如果Region进行了垃圾回收，之后可能又会变成老年代，也就是说Region的区域功能可能会动态变化。

G1垃圾收集器对于对象什么时候会转移到老年代跟之前讲过的原则一样，**唯一不同的是对大对象的处理**，G1有专门分配大对象的Region叫**Humongous区**，而不是让大对象直接进入老年代的Region中。在G1中，大对象的判定规则就是一个大对象超过了一个Region大小的50%，比如按照上面算的，每个Region是2M，只要一个大对象超过了1M，就会被放入Humongous中，而且一个大对象如果太大，可能会横跨多个Region来存放。

Humongous区专门存放短期巨型对象，不用直接进老年代，可以节约老年代的空间，避免因为老年代空间不够的GC开销。

Full GC的时候除了收集年轻代和老年代之外，也会将Humongous区一并回收。

G1收集器一次GC(主要值Mixed GC)的运作过程大致分为以下几个步骤：

*  **初始标记**（initial mark，STW）：暂停所有的其他线程，并记录下gc roots直接能引用的对象，**速度很快** ；
 *  **并发标记**（Concurrent Marking）：同CMS的并发标记。并发标记阶段就是从GC Roots的直接关联对象开始遍历整个对象图的过程， 这个过程耗时较长但是不需要停顿用户线程， 可以与垃圾收集线程一起并发运行。因为用户程序继续运行，可能会有导致已经标记过的对象状态发生改变。并发标记阶段时间最长大概占整个垃圾收集过程时间的80%，但是是并发的用户感知。
 *  **最终标记**（Remark，STW）：同CMS的重新标记。重新标记阶段就是为了修正并发标记期间因为用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，**这个阶段的停顿时间一般会比初始标记阶段的时间稍长，远远比并发标记阶段时间短。主要用到三色标记里的\*\*\*\*增量更新算法(见下面详解)做重新标记。**
 *  **筛选回收**（Cleanup，STW）：筛选回收阶段首先对各个Region的**回收价值和成本进行排序**，**根据用户所期望的GC停顿STW时间(可以用JVM参数 -XX:MaxGCPauseMillis指定)来制定回收计划**，比如说老年代此时有1000个Region都满了，但是因为根据预期停顿时间，本次垃圾回收可能只能停顿200毫秒，那么通过之前回收成本计算得知，可能回收其中800个Region刚好需要200ms，那么就只会回收800个Region(**Collection Set**，要回收的集合)，尽量把GC导致的停顿时间控制在我们指定的范围内。这个阶段其实也可以做到与用户程序一起并发执行，但是因为只回收一部分Region，时间是用户可控制的，而且停顿用户线程将大幅提高收集效率。不管是年轻代或是老年代，**回收算法主要用的是复制算法**，**将一个region中的存活对象复制到另一个region中，这种不会像CMS那样回收完因为有很多内存碎片还需要整理一次，G1采用复制算法回收几乎不会有太多内存碎片**。(注意：CMS回收阶段是跟用户线程一起并发执行的，G1因为内部实现太复杂暂时没实现并发回收，不过到了ZGC，Shenandoah就实现了并发收集，Shenandoah可以看成是G1的升级版本)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 2]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 3]

**G1收集器在后台维护了一个优先列表，每次根据允许的收集时间，优先选择回收价值最大的Region(这也就是它的名字Garbage-First的由来)，比如一个Region花200ms能回收10M垃圾，另外一个Region花50ms能回收20M垃圾，在回收时间有限情况下，G1当然会优先选择后面这个Region回收**。这种使用Region划分内存空间以及有优先级的区域回收方式，保证了G1收集器在有限时间内可以尽可能高的收集效率。

被视为JDK1.7以上版本Java虚拟机的一个重要进化特征。它具备以下特点：

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

毫无疑问， 可以由用户指定期望的停顿时间是G1收集器很强大的一个功能， 设置不同的期望停顿时间， 可使得G1在不同应用场景中取得关注吞吐量和关注延迟之间的最佳平衡。 不过， 这里设置的“期望值”必须是符合实际的， 不能异想天开， 毕竟G1是要冻结用户线程来复制对象的， 这个停顿时

间再怎么低也得有个限度。 它默认的停顿目标为两百毫秒， 一般来说， 回收阶段占到几十到一百甚至接近两百毫秒都很正常， 但如果我们把停顿时间调得非常低， 譬如设置为二十毫秒， 很可能出现的结果就是由于停顿目标时间太短， 导致每次选出来的回收集只占堆内存很小的一部分， 收集器收集的速度逐渐跟不上分配器分配的速度， 导致垃圾慢慢堆积。 很可能一开始收集器还能从空闲的堆内存中获得一些喘息的时间， 但应用运行时间一长就不行了， 最终占满堆引发Full GC反而降低性能， 所以通常把期望停顿时间设置为一两百毫秒或者两三百毫秒会是比较合理的。

**G1垃圾收集分类**

**YoungGC**  
**G1计算回收时间接近参数 -XX:MaxGCPauseMills 设定的值，那么就会触发Young GC**

YoungGC并不是说现有的Eden区放满了就会马上触发，G1会计算下现在Eden区回收大概要多久时间，如果回收时间远远小于参数 -XX:MaxGCPauseMills 设定的值，那么增加年轻代的region，继续给新对象存放，不会马上做Young GC，直到下一次Eden区放满，G1计算回收时间接近参数 -XX:MaxGCPauseMills 设定的值，那么就会触发Young GC

**MixedGC**  
**老年代的堆占有率达到参数(**\-XX:InitiatingHeapOccupancyPercent\*\*)设定的值则触发（默认设置为45%就会触发）\*\*

不是FullGC，老年代的堆占有率达到参数(**-XX:InitiatingHeapOccupancyPercent**)设定的值则触发（默认设置为45%就会触发），回收所有的Young和部分Old(根据期望的GC停顿时间确定old区垃圾收集的优先顺序)以及**大对象区**，正常情况G1的垃圾收集是先做MixedGC，主要使用复制算法，需要把各个region中存活的对象拷贝到别的region里去，拷贝过程中如果发现**没有足够的空region**能够承载拷贝对象就会触发一次Full GC

**Full GC**  
**MixedGC时将老年代非垃圾对象拷贝到别的region，发现没有足够的空间就会触发一次full Gc**  
停止系统程序，然后采用单线程进行标记、清理和压缩整理，好空闲出来一批Region来供下一次MixedGC使用，这个过程是非常耗时的。(Shenandoah优化成多线程收集了)

**G1收集器参数设置**

**G1的参数一般默认就可以了，需要调整的很少**

\-XX:+UseG1GC:使用G1收集器

\-XX:ParallelGCThreads:指定GC工作的线程数量

\-XX:G1HeapRegionSize:指定分区大小(1MB~32MB，且必须是2的N次幂)，默认将整堆划分为2048个分区

\-XX:MaxGCPauseMillis:目标暂停时间(默认200ms)

\-XX:G1NewSizePercent:新生代内存初始空间(默认整堆5%，会根据gc停顿时间自动调整，不需要修改，值配置整数，默认就是百分比)

\-XX:G1MaxNewSizePercent:新生代内存最大空间(默认60%)

\-XX:TargetSurvivorRatio: survivor区移到老年代的条件，survivor占用达到50%。 Survivor区的填充容量(默认50%)，Survivor区域里的一批对象(年龄1+年龄2+年龄n的多个年龄对象)总和超过了Survivor区域的50%，此时就会把年龄n(含)以上的对象都放入老年代

\-XX:MaxTenuringThreshold: survivor区移到老年代的条件，survivor区非垃圾对象被复制次数到达15。 最大年龄阈值(默认15)

\-XX:InitiatingHeapOccupancyPercent: 发生**MixedGC**的条件， 老年代region个数被使用占到45%。 老年代占用空间达到整堆内存阈值(默认45%)，则执行新生代和老年代的混合收集(**MixedGC**)，比如我们之前说的堆默认有2048个region，如果有接近1000个region都是老年代的region，则可能就要触发MixedGC了

\-XX:G1MixedGCLiveThresholdPercent(默认85%不需要调) region中的存活对象低于这个值时才会回收该region，如果超过这个值，存活对象过多，回收的的意义不大。

\-XX:G1MixedGCCountTarget:在一次回收过程中指定做几次筛选回收(默认8次)，在最后一个筛选回收阶段可以回收一会，然后暂停回收，恢复系统运行，一会再开始回收，这样可以让系统不至于单次停顿时间过长。

\-XX:G1HeapWastePercent(默认5%): gc过程中空出来的region是否充足阈值，在混合回收的时候，对Region回收都是基于复制算法进行的，都是把要回收的Region里的存活对象放入其他Region，然后这个Region中的垃圾对象全部清理掉，这样的话在回收过程就会不断空出来新的Region，一旦空闲出来的Region数量达到了堆内存的5%，此时就会立即停止混合回收，意味着本次混合回收就结束了。

**需要调整的参数。**  
**G1垃圾收集器优化建议**

假设参数 -XX:MaxGCPauseMills(GC的停顿时间) 设置的值很大，导致系统运行很久，年轻代可能都占用了堆内存的60%了，此时才触发年轻代gc。

那么存活下来的对象可能就会很多，此时就会导致Survivor区域放不下那么多的对象，就会进入老年代中。

或者是你年轻代gc过后，存活下来的对象过多，导致进入Survivor区域后触发了动态年龄判定规则，达到了Survivor区域的50%，也会快速导致一些对象进入老年代中。

所以这里核心还是在于调节 -XX:MaxGCPauseMills 这个参数的值，在保证他的年轻代gc别太频繁的同时，还得考虑每次gc过后的存活对象有多少,避免存活对象太多快速进入老年代，频繁触发mixed gc.

**什么场景适合使用G1**

1.  50%以上的堆被存活对象占用
2.  对象分配和晋升的速度变化非常大
3.  垃圾回收时间特别长，超过1秒
4.  8GB以上的堆内存(建议值)
5.  停顿时间是500ms以内

**每秒几十万并发的系统如何优化JVM**

rocketMq和kafka线上建议使用32G以上的内存，一般线上64G

Kafka类似的支撑高并发消息系统大家肯定不陌生，对于kafka来说，每秒处理几万甚至几十万消息时很正常的，一般来说部署kafka需要用大内存机器(比如64G)，也就是说可以给年轻代分配个三四十G的内存用来支撑高并发处理，这里就涉及到一个问题了，我们以前常说的对于eden区的young gc是很快的，这种情况下它的执行还会很快吗？很显然，不可能，因为内存太大，处理还是要花不少时间的，假设三四十G内存回收可能最快也要几秒钟，按kafka这个并发量放满三四十G的eden区可能也就一两分钟吧，那么意味着整个系统每运行一两分钟就会因为young gc卡顿几秒钟没法处理新消息，显然是不行的。那么对于这种情况如何优化了，我们可以使用G1收集器，设置 -XX:MaxGCPauseMills 为50ms，假设50ms能够回收三到四个G内存，然后50ms的卡顿其实完全能够接受，用户几乎无感知，那么整个系统就可以在卡顿几乎无感知的情况下一边处理业务一边收集垃圾。

G1天生就适合这种大内存机器的JVM运行，可以比较完美的解决大内存垃圾回收时间过长的问题。

## ZGC收集器(-XX:+UseZGC) ##

面试问的很少

ZGC是一款JDK 11中新加入的具有实验性质的低延迟垃圾收集器，ZGC可以说源自于是Azul System公司开发的C4（Concurrent Continuously Compacting Collector） 收集器。

**ZGC目标**

如下图所示，ZGC的目标主要有4个：

![0][0 15]

*  **支持TB量级的堆**。我们生产环境的硬盘还没有上TB呢，这应该可以满足未来十年内，所有JAVA应用的需求了吧。
 *  **最大GC停顿时间不超10ms**。目前一般线上环境运行良好的JAVA应用Minor GC停顿时间在10ms左右，Major GC一般都需要100ms以上（G1可以调节停顿时间，但是如果调的过低的话，反而会适得其反），之所以能做到这一点是因为它的停顿时间主要跟Root扫描有关，而Root数量和堆大小是没有任何关系的。
 *  **奠定未来GC特性的基础**。
 *  **最糟糕的情况下吞吐量会降低15%**。这都不是事，停顿时间足够优秀。至于吞吐量，通过扩容分分钟解决。

另外，Oracle官方提到了它最大的优点是：它的停顿时间不会随着堆的增大而增长！也就是说，几十G堆的停顿时间是10ms以下，几百G甚至上T堆的停顿时间也是10ms以下。

**不分代(暂时)**

## 可达性分析垃圾收集底层算法实现 ##

--------------------

**三色标记**

**在并发标记的过程中**\*\*，因为标记期间应用线程还在继续跑，对象间的引用可能发生变化，多标和漏标的情况就有可能发生。\*\*

**这里我们引入“三色标记”来给大家解释下，把Gcroots可达性分析遍历对象过程中遇到的对象， 按照“是否访问过”这个条件标记成以下三种颜色：**

*  **黑色**：已经分析过 表示对象已经被垃圾收集器访问过， 且这个对象的所有引用都已经扫描过。 黑色的对象代表已经扫描过， 它是安全存活的， 如果有其他对象引用指向了黑色对象， 无须重新扫描一遍。 黑色对象不可能直接（不经过灰色对象） 指向某个白色对象。
 *  **灰色**： 表示对象已经被垃圾收集器访问过， 但这个对象上至少存在一个引用还没有被扫描过。
 *  **白色**： 表示对象尚未被垃圾收集器访问过。 显然在可达性分析刚刚开始的阶段， 所有的对象都是白色的， 若在分析结束的阶段， 仍然是白色的对象， 即代表不可达。  
    ![0][0 16]

# 7.如何选择垃圾收集器 #

1.  优先调整堆的大小让服务器自己来选择
2.  如果内存小于100M，使用串行收集器
3.  如果是单核，并且没有停顿时间的要求，串行或JVM自己选择
4.  如果允许停顿时间超过1秒，选择并行或者JVM自己选
5.  如果响应时间最重要，并且不能超过1秒，使用并发收集器
6.  **4G以下可以用parallel，4-8G可以用ParNew+CMS，8G以上可以用G1，几百G以上用ZGC**

**下图有连线的可以搭配使用**  
![0][0 17]

**JDK 1.8默认使用 Parallel(年轻代和老年代都是)**

**JDK 1.9默认使用 G1**

# 8…JVM调优工具详解及调优实战 #

**前置启动程序**

事先启动一个web应用程序，用jps查看其进程id，接着用各种jdk自带命令优化应用

## Jmap ##

jmap -histo 1466 > ./log.txt  #查看历史生成的实例，输出到文件
    jmap -histo:live 14660   #查看当前存活的实例，执行过程中可能会触发一次full gc
    jmap -heap 1466  #jmap -heap 14660

**查看内存信息，实例个数以及占用内存大小**  
 ![0][0 18]

jmap -histo 14660 \#查看历史生成的实例 jmap -histo:live 14660 \#查看当前存活的实例，执行过程中可能会触发一次full gc

jmap -histo 1466 > ./log.txt

打开log.txt，文件内容如下：  
 ![0][0 19]

*  num：序号
 *  instances：实例数量
 *  bytes：占用空间大小
 *  class name：类名称，\[C is a char\[\]，\[S is a short\[\]，\[I is a int\[\]，\[B is a byte\[\]，\[\[I is a int\[\]\[\]

**查看堆信息**

jmap -heap 14660

![0][0 20]

堆内存dump

jmap -dump:format=b,file=eureka.hprof 14660

![0][0 21]

也可以设置内存溢出自动导出dump文件(内存很大的时候，可能会导不出来)

1.  \-XX:+HeapDumpOnOutOfMemoryError
2.  \-XX:HeapDumpPath=./ （路径）

示例代码：

public class OOMTest { 
    
       public static List<Object> list = new ArrayList<>();
    
       // JVM设置 
       // -Xms10M -Xmx10M -XX:+PrintGCDetails -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=D:\jvm.dump 
       public static void main(String[] args) { 
          List<Object> list = new ArrayList<>();
          int i = 0;
          int j = 0;
          while (true) { 
             list.add(new User(i++, UUID.randomUUID().toString()));
             new User(j--, UUID.randomUUID().toString());
          }
       }
    }

**可以用jvisualvm命令工具导入该dump文件分析**

![0][0 22]

## Jstack ##

jstack -l  28965  > test.js  # 用jstack加进程id查找死锁
    top -p 进程号 #查看一个进程的cpu/内存使用情况
    然后按大写的H 查看该进化所有线程的cpu/内存使用情况
    jstack 19663|grep -A 10 4cd0   #jstack找出占用cpu最高的线程堆栈信息，从堆栈中可以发现导致cpu飙高的调用方法

用jstack加进程id查找死锁，见如下示例

public class DeadLockTest { 
    
       private static Object lock1 = new Object();
       private static Object lock2 = new Object();
    
       public static void main(String[] args) { 
          new Thread(() -> { 
             synchronized (lock1) { 
                try { 
                   System.out.println("thread1 begin");
                   Thread.sleep(5000);
                } catch (InterruptedException e) { 
                }
                synchronized (lock2) { 
                   System.out.println("thread1 end");
                }
             }
          }).start();
    
          new Thread(() -> { 
             synchronized (lock2) { 
                try { 
                   System.out.println("thread2 begin");
                   Thread.sleep(5000);
                } catch (InterruptedException e) { 
                }
                synchronized (lock1) { 
                   System.out.println("thread2 end");
                }
             }
          }).start();
    
          System.out.println("main thread end");
       }
    }

![0][0 23]

“Thread-1” 线程名

prio=5 优先级=5

tid=0x000000001fa9e000 线程id

nid=0x2d64 线程对应的本地线程标识nid

java.lang.Thread.State: BLOCKED 线程状态

![0][0 24]

还可以用jvisualvm自动检测死锁

![0][0 25]

**远程连接jvisualvm**

**启动普通的jar程序JMX端口配置：**

java -Dcom.sun.management.jmxremote.port=8888 -Djava.rmi.server.hostname=192.168.65.60 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -jar microservice-eureka-server.jar

PS：

\-Dcom.sun.management.jmxremote.port 为远程机器的JMX端口

\-Djava.rmi.server.hostname 为远程机器IP

**tomcat的JMX配置：在catalina.sh文件里的最后一个JAVA\_OPTS的赋值语句下一行增加如下配置行**

JAVA\_OPTS="$JAVA\_OPTS -Dcom.sun.management.jmxremote.port=8888 -Djava.rmi.server.hostname=192.168.50.60 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false"

连接时确认下端口是否通畅，可以临时关闭下防火墙

systemctl stop firewalld \#临时关闭防火墙

**jstack找出占用cpu最高的线程堆栈信息**

package com.tuling.jvm; /\*\* \* 运行此代码，cpu会飙高 \*/ public class Math \{ public static final int initData = 666; public static User user = new User(); public int compute() \{ //一个方法对应一块栈帧内存区域 int a = 1; int b = 2; int c = (a + b) \* 10; return c; \} public static void main(String\[\] args) \{ Math math = new Math(); while (true)\{ math.compute(); \} \} \}

1，使用命令top -p ，显示你的java进程的内存情况，pid是你的java进程号，比如19663

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 4]

2，按H，获取每个线程的内存情况

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 5]

3，找到内存和cpu占用最高的线程tid，比如19664

4，将十进制线程号19664转为十六进制得到 0x4cd0，此为线程id的十六进制表示

5，执行 jstack 19663|grep -A 10 4cd0，得到线程堆栈信息中 4cd0 这个线程所在行的后面10行，从堆栈中可以发现导致cpu飙高的调用方法

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 6]

6，查看对应的堆栈信息找出可能存在问题的代码

## Jinfo ##

查看正在运行的Java应用程序的扩展参数

查看jvm的参数

![0][0 26]

查看java系统参数

![0][0 27]

## Jstat(排查调优使用最多的命令) ##

jstat命令可以查看堆内存各部分的使用量，以及加载类的数量。命令的格式如下：

jstat \[-命令选项\] \[vmid\] \[间隔时间(毫秒)\] \[查询次数\]

jstat -gc  28010 1000 5

![在这里插入图片描述][20210202110206149.png]

注意：使用的jdk版本是jdk8

垃圾回收统计

**jstat -gc pid 最常用**，可以评估程序内存使用及GC压力整体情况

![0][0 28]  
![在这里插入图片描述][20210201170756261.png]

*  S0C：第一个幸存区的大小，单位KB
 *  S1C：第二个幸存区的大小
 *  S0U：第一个幸存区的使用大小
 *  S1U：第二个幸存区的使用大小
 *  EC：伊甸园区的大小
 *  EU：伊甸园区的使用大小
 *  OC：老年代大小
 *  OU：老年代使用大小
 *  MC：方法区大小(元空间)
 *  MU：方法区使用大小
 *  CCSC:压缩类空间大小
 *  CCSU:压缩类空间使用大小
 *  YGC：年轻代垃圾回收次数
 *  YGCT：年轻代垃圾回收消耗时间，单位s
 *  FGC：老年代垃圾回收次数
 *  FGCT：老年代垃圾回收消耗时间，单位s
 *  GCT：垃圾回收消耗总时间，单位s

堆内存统计

![0][0 29]

*  NGCMN：新生代最小容量
 *  NGCMX：新生代最大容量
 *  NGC：当前新生代容量
 *  S0C：第一个幸存区大小
 *  S1C：第二个幸存区的大小
 *  EC：伊甸园区的大小
 *  OGCMN：老年代最小容量
 *  OGCMX：老年代最大容量
 *  OGC：当前老年代大小
 *  OC:当前老年代大小
 *  MCMN:最小元数据容量
 *  MCMX：最大元数据容量
 *  MC：当前元数据空间大小
 *  CCSMN：最小压缩类空间大小
 *  CCSMX：最大压缩类空间大小
 *  CCSC：当前压缩类空间大小
 *  YGC：年轻代gc次数
 *  FGC：老年代GC次数

新生代垃圾回收统计

![0][0 30]

*  S0C：第一个幸存区的大小
 *  S1C：第二个幸存区的大小
 *  S0U：第一个幸存区的使用大小
 *  S1U：第二个幸存区的使用大小
 *  TT:对象在新生代存活的次数
 *  MTT:对象在新生代存活的最大次数
 *  DSS:期望的幸存区大小
 *  EC：伊甸园区的大小
 *  EU：伊甸园区的使用大小
 *  YGC：年轻代垃圾回收次数
 *  YGCT：年轻代垃圾回收消耗时间

新生代内存统计

![0][0 31]

*  NGCMN：新生代最小容量
 *  NGCMX：新生代最大容量
 *  NGC：当前新生代容量
 *  S0CMX：最大幸存1区大小
 *  S0C：当前幸存1区大小
 *  S1CMX：最大幸存2区大小
 *  S1C：当前幸存2区大小
 *  ECMX：最大伊甸园区大小
 *  EC：当前伊甸园区大小
 *  YGC：年轻代垃圾回收次数
 *  FGC：老年代回收次数

老年代垃圾回收统计

![0][0 32]

*  MC：方法区大小
 *  MU：方法区使用大小
 *  CCSC:压缩类空间大小
 *  CCSU:压缩类空间使用大小
 *  OC：老年代大小
 *  OU：老年代使用大小
 *  YGC：年轻代垃圾回收次数
 *  FGC：老年代垃圾回收次数
 *  FGCT：老年代垃圾回收消耗时间
 *  GCT：垃圾回收消耗总时间

老年代内存统计

![0][0 33]

*  OGCMN：老年代最小容量
 *  OGCMX：老年代最大容量
 *  OGC：当前老年代大小
 *  OC：老年代大小
 *  YGC：年轻代垃圾回收次数
 *  FGC：老年代垃圾回收次数
 *  FGCT：老年代垃圾回收消耗时间
 *  GCT：垃圾回收消耗总时间

元数据空间统计

![0][0 34]

*  MCMN:最小元数据容量
 *  MCMX：最大元数据容量
 *  MC：当前元数据空间大小
 *  CCSMN：最小压缩类空间大小
 *  CCSMX：最大压缩类空间大小
 *  CCSC：当前压缩类空间大小
 *  YGC：年轻代垃圾回收次数
 *  FGC：老年代垃圾回收次数
 *  FGCT：老年代垃圾回收消耗时间
 *  GCT：垃圾回收消耗总时间

![0][0 35]

*  S0：幸存1区当前使用比例
 *  S1：幸存2区当前使用比例
 *  E：伊甸园区使用比例
 *  O：老年代使用比例
 *  M：元数据区使用比例
 *  CCS：压缩使用比例
 *  YGC：年轻代垃圾回收次数
 *  FGC：老年代垃圾回收次数
 *  FGCT：老年代垃圾回收消耗时间
 *  GCT：垃圾回收消耗总时间

# 6.jvm调优 #

**jvm调优 调优主要针对full gc**

**优化思路**其实简单来说就是尽量让每次Young GC后的存活对象小于Survivor区域的50%，都留存在年轻代里。尽量别让对象进入老年代。尽量减少Full GC的频率，避免频繁Full GC对JVM性能的影响。

对象频繁进入老年代的问题，其实**很多优化无非就是让短期存活的对象尽量都留在survivor里，不要进入老年代，这样在minor gc的时候这些对象都会被回收，不会进到老年代从而导致full gc**。

对于对象年龄应该为多少才移动到老年代比较合适，本例中一次minor gc要间隔二三十秒，大多数对象一般在几秒内就会变为垃圾，完全可以将默认的15岁改小一点，比如改为5，那么意味着对象要经过5次minor gc才会进入老年代，整个时间也有一两分钟了，如果对象这么长时间都没被回收，完全可以认为这些对象是会存活的比较长的对象，可以移动到老年代，而不是继续一直占用survivor区空间。

对于多大的对象直接进入老年代(参数-XX:PretenureSizeThreshold)，这个一般可以结合你自己系统看下有没有什么大对象生成，预估下大对象的大小，一般来说设置为1M就差不多了，很少有超过1M的大对象，这些对象一般就是你系统初始化分配的缓存对象，比如大的缓存List，Map之类的对象。

可以适当调整JVM参数如下：

-Xms3072M -Xmx3072M -Xmn2048M -Xss1M -XX:MetaspaceSize=256M -XX:MaxMetaspaceSize=256M -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=5 -XX:PretenureSizeThreshold=1M

## JVM运行情况预估 ##

用 jstat gc -pid 命令可以计算出如下一些关键数据，有了这些数据就可以采用之前介绍过的优化思路，先给自己的系统设置一些初始性的JVM参数，比如堆内存大小，年轻代大小，Eden和Survivor的比例，老年代的大小，大对象的阈值，大龄对象进入老年代的阈值等。

**年轻代对象增长的速率**

可以执行命令 jstat -gc pid 1000 10 (每隔1秒执行1次命令，共执行10次)，通过观察EU(eden区的使用)来估算每秒eden大概新增多少对象，如果系统负载不高，可以把频率1秒换成1分钟，甚至10分钟来观察整体情况。注意，一般系统可能有高峰期和日常期，所以需要在不同的时间分别估算不同情况下对象增长速率。

**Young GC的触发频率和每次耗时**

知道年轻代对象增长速率我们就能推根据eden区的大小推算出Young GC大概多久触发一次，Young GC的平均耗时可以通过 YGCT/YGC 公式算出，根据结果我们大概就能知道**系统大概多久会因为Young GC的执行而卡顿多久。**

**每次Young GC后有多少对象存活和进入老年代**

这个因为之前已经大概知道Young GC的频率，假设是每5分钟一次，那么可以执行命令 jstat -gc pid 300000 10 ，观察每次结果eden，survivor和老年代使用的变化情况，在每次gc后eden区使用一般会大幅减少，survivor和老年代都有可能增长，这些增长的对象就是每次Young GC后存活的对象，同时还可以看出每次Young GC后进去老年代大概多少对象，从而可以推算出**老年代对象增长速率。**

**Full GC的触发频率和每次耗时**

知道了老年代对象的增长速率就可以推算出Full GC的触发频率了，Full GC的每次耗时可以用公式 FGCT/FGC 计算得出。

**系统频繁Full GC导致系统卡顿是怎么回事**

*  机器配置：2核4G
 *  JVM内存大小：2G
 *  系统运行时间：7天
 *  期间发生的Full GC次数和耗时：500多次，200多秒
 *  期间发生的Young GC次数和耗时：1万多次，500多秒

大致算下来每天会发生70多次Full GC，平均每小时3次，每次Full GC在400毫秒左右；

每天会发生1000多次Young GC，每分钟会发生1次，每次Young GC在50毫秒左右。

JVM参数设置如下：

-Xms1536M -Xmx1536M -Xmn512M -Xss256K -XX:SurvivorRatio=6 -XX:MetaspaceSize=256M -XX:MaxMetaspaceSize=256M -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=75 -XX:+UseCMSInitiatingOccupancyOnly

![0][0 36]

大家可以结合**对象挪动到老年代那些规则**推理下我们这个程序可能存在的一些问题

经过分析感觉可能会由于对象动态年龄判断机制导致full gc较为频繁

为了给大家看效果，我模拟了一个示例程序(见课程对应工程代码：jvm-full-gc)，打印了jstat的结果如下：

jstat -gc 13456 2000 10000

![0][0 37]

对于对象动态年龄判断机制导致的full gc较为频繁可以先试着优化下JVM参数，把年轻代适当调大点：

-Xms1536M -Xmx1536M -Xmn1024M -Xss256K -XX:SurvivorRatio=6 -XX:MetaspaceSize=256M -XX:MaxMetaspaceSize=256M -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=92 -XX:+UseCMSInitiatingOccupancyOnly

![0][0 38]

优化完发现没什么变化，**full gc的次数比minor gc的次数还多了**

![0][0 39]

我们可以推测下full gc比minor gc还多的原因有哪些？

1、元空间不够导致的多余full gc

2、显示调用System.gc()造成多余的full gc，这种一般线上尽量通过-XX:+DisableExplicitGC参数禁用，如果加上了这个JVM启动参数，那么代码中调用System.gc()没有任何效果

3、老年代空间分配担保机制

最快速度分析完这些我们推测的原因以及优化后，我们发现young gc和full gc依然很频繁了，而且看到有大量的对象频繁的被挪动到老年代，这种情况我们可以借助jmap命令大概看下是什么对象

![0][0 40]

查到了有大量User对象产生，这个可能是问题所在，但不确定，还必须找到对应的代码确认，如何去找对应的代码了？

1、代码里全文搜索生成User对象的地方(适合只有少数几处地方的情况)

2、如果生成User对象的地方太多，无法定位具体代码，我们可以同时分析下占用cpu较高的线程，一般有大量对象不断产生，对应的方法代码肯定会被频繁调用，占用的cpu必然较高

可以用上面讲过的jstack或jvisualvm来定位cpu使用较高的代码，最终定位到的代码如下：

import java.util.ArrayList; @RestController public class IndexController \{ @RequestMapping("/user/process") public String processUserData() throws InterruptedException \{ ArrayList users = queryUsers(); for (User user: users) \{ //TODO 业务处理 System.out.println(“user:” + user.toString()); \} return “end”; \} /\*\* \* 模拟批量查询用户场景 \* @return \*/ private ArrayList queryUsers() \{ ArrayList users = new ArrayList<>(); for (int i = 0; i < 5000; i++) \{ users.add(new User(i,“zhuge”)); \} return users; \} \}

同时，java的代码也是需要优化的，一次查询出500M的对象出来，明显不合适，要根据之前说的各种原则尽量优化到合适的值，尽量消除这种朝生夕死的对象导致的full gc

**内存泄露到底是怎么回事**

再给大家讲一种情况，一般电商架构可能会使用多级缓存架构，就是redis加上JVM级缓存，大多数同学可能为了图方便对于JVM级缓存就简单使用一个hashmap，于是不断往里面放缓存数据，但是很少考虑这个map的容量问题，结果这个缓存map越来越大，一直占用着老年代的很多空间，时间长了就会导致full gc非常频繁，这就是一种内存泄漏，对于一些老旧数据没有及时清理导致一直占用着宝贵的内存资源，时间长了除了导致full gc，还有可能导致OOM。

这种情况完全可以考虑采用一些成熟的JVM级缓存框架来解决，比如ehcache等自带一些LRU数据淘汰算法的框架来作为JVM级的缓存。

# 9.JVM调优实战及常量池详解 #

## 阿里巴巴Arthas(阿尔萨斯)详解 ##

**阿里巴巴Arthas详解**

--------------------

**Arthas(阿尔萨斯)** 是 Alibaba 在 2018 年 9 月开源的 **Java 诊断**工具。支持 JDK6+， 采用命令行交互模式，可以方便的定位和诊断线上程序运行问题。**Arthas** 官方文档十分详细，详见：[*https://alibaba.github.io/arthas*][https_alibaba.github.io_arthas]

**Arthas\*\*\*\*使用场景**

得益于 **Arthas** 强大且丰富的功能，让 **Arthas** 能做的事情超乎想象。下面仅仅列举几项常见的使用情况，更多的使用场景可以在熟悉了 **Arthas** 之后自行探索。

1.  是否有一个全局视角来查看系统的运行状况？
2.  为什么 CPU 又升高了，到底是哪里占用了 CPU ？
3.  运行的多线程有死锁吗？有阻塞吗？
4.  程序运行耗时很长，是哪里耗时比较长呢？如何监测呢？
5.  这个类从哪个 jar 包加载的？为什么会报各种类相关的 Exception？
6.  我改的代码为什么没有执行到？难道是我没 commit？分支搞错了？
7.  遇到问题无法在线上 debug，难道只能通过加日志再重新发布吗？
8.  有什么办法可以监控到 JVM 的实时运行状态？

**Arthas\*\*\*\*使用**

\# github下载arthas wget https://alibaba.github.io/arthas/arthas-boot.jar \# 或者 Gitee 下载 wget https://arthas.gitee.io/arthas-boot.jar

用java -jar运行即可，可以识别机器上所有Java进程(我们这里之前已经运行了一个Arthas测试程序，代码见下方)

![0][0 41]

package com.tuling.jvm; import java.util.HashSet; public class Arthas \{ private static HashSet hashSet = new HashSet(); public static void main(String\[\] args) \{ // 模拟 CPU 过高 cpuHigh(); // 模拟线程死锁 deadThread(); // 不断的向 hashSet 集合增加数据 addHashSetThread(); \} /\*\* \* 不断的向 hashSet 集合添加数据 */ public static void addHashSetThread() \{ // 初始化常量 new Thread(() -> \{ int count = 0; while (true) \{ try \{ hashSet.add(“count” + count); Thread.sleep(1000); count++; \} catch (InterruptedException e) \{ e.printStackTrace(); \} \} \}).start(); \} public static void cpuHigh() \{ new Thread(() -> \{ while (true) \{ \} \}).start(); \} /*\* \* 死锁 */ private static void deadThread() \{ /*\* 创建资源 \*/ Object resourceA = new Object(); Object resourceB = new Object(); // 创建线程 Thread threadA = new Thread(() -> \{ synchronized (resourceA) \{ System.out.println(Thread.currentThread() + " get ResourceA"); try \{ Thread.sleep(1000); \} catch (InterruptedException e) \{ e.printStackTrace(); \} System.out.println(Thread.currentThread() + “waiting get resourceB”); synchronized (resourceB) \{ System.out.println(Thread.currentThread() + " get resourceB"); \} \} \}); Thread threadB = new Thread(() -> \{ synchronized (resourceB) \{ System.out.println(Thread.currentThread() + " get ResourceB"); try \{ Thread.sleep(1000); \} catch (InterruptedException e) \{ e.printStackTrace(); \} System.out.println(Thread.currentThread() + “waiting get resourceA”); synchronized (resourceA) \{ System.out.println(Thread.currentThread() + " get resourceA"); \} \} \}); threadA.start(); threadB.start(); \} \}

选择进程序号1，进入进程信息操作

![0][0 42]

输入**dashboard**可以查看整个进程的运行情况，线程、内存、GC、运行环境信息：

![0][0 43]

输入**thread**可以查看线程详细情况

![0][0 44]

输入 **thread加上线程ID** 可以查看线程堆栈

![0][0 45]

输入 **thread -b** 可以查看线程死锁

![0][0 46]

**输入 jad加类的全名 可以反编译，这样可以方便我们查看线上代码是否是正确的版本**

![0][0 47]

**使用 ognl 命令可以查看线上系统变量的值，甚至可以修改变量的值**

![0][0 48]

![0][0 49]

更多命令使用可以用help命令查看，或查看文档：https://alibaba.github.io/arthas/commands.html\#arthas

## 打印GC日志(GC日志详解) ##

--------------------

对于java应用我们可以通过一些配置把程序运行过程中的gc日志全部打印出来，然后分析gc日志得到关键性指标，分析GC原因，调优JVM参数。

打印GC日志方法，在JVM参数里增加参数，%t 代表时间

\-Xloggc:./gc-%t.log -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCTimeStamps -XX:+PrintGCCause -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=100M

Tomcat则直接加在JAVA\_OPTS变量里。

**如何分析GC日志**

运行程序加上对应gc日志

java -jar -Xloggc:./gc-%t.log -XX:+PrintGCDetails -XX:+PrintGCDateStamps  -XX:+PrintGCTimeStamps -XX:+PrintGCCause  
    -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=100M microservice-eureka-server.jar

#打印gc日志到文件.log文件 ，需要打印的信息
     -Xloggc:./gc-%t.log -XX:+PrintGCDetails -XX:+PrintGCDateStamps  -XX:+PrintGCTimeStamps -XX:+PrintGCCause

#滚动输出日志防止一个日志文件太大
     -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=100M

**CMS**

-Xloggc:d:/gc-cms-%t.log -Xms50M -Xmx50M -XX:MetaspaceSize=256M -XX:MaxMetaspaceSize=256M -XX:+PrintGCDetails -XX:+PrintGCDateStamps  
     -XX:+PrintGCTimeStamps -XX:+PrintGCCause  -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=100M 
     -XX:+UseParNewGC -XX:+UseConcMarkSweepGC

**G1**

-Xloggc:d:/gc-g1-%t.log -Xms50M -Xmx50M -XX:MetaspaceSize=256M -XX:MaxMetaspaceSize=256M -XX:+PrintGCDetails -XX:+PrintGCDateStamps  
     -XX:+PrintGCTimeStamps -XX:+PrintGCCause  -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=100M -XX:+UseG1GC

下图中是我截取的JVM刚启动的一部分GC日志

![0][0 50]

我们可以看到图中第一行红框，是项目的配置参数。这里不仅配置了打印GC日志，还有相关的VM内存参数。

第二行红框中的是在这个GC时间点发生GC之后相关GC情况。

1、对于**2.909：** 这是从jvm启动开始计算到这次GC经过的时间，前面还有具体的发生时间日期。

2、Full GC(Metadata GC Threshold)指这是一次full gc，括号里是gc的原因， PSYoungGen是年轻代的GC，ParOldGen是老年代的GC，Metaspace是元空间的GC

3、 6160K->0K(141824K)，这三个数字分别对应GC之前占用年轻代的大小，GC之后年轻代占用，以及整个年轻代的大小。

4、112K->6056K(95744K)，这三个数字分别对应GC之前占用老年代的大小，GC之后老年代占用，以及整个老年代的大小。

5、6272K->6056K(237568K)，这三个数字分别对应GC之前占用堆内存的大小，GC之后堆内存占用，以及整个堆内存的大小。

6、20516K->20516K(1069056K)，这三个数字分别对应GC之前占用元空间内存的大小，GC之后元空间内存占用，以及整个元空间内存的大小。

7、0.0209707是该时间点GC总耗费时间。

从日志可以发现几次fullgc都是由于元空间不够导致的，所以我们可以将元空间调大点  
\-XX:MetaspaceSize=256M -XX:MaxMetaspaceSize=256M 如果jar较大(例如1g),元空间调大可以提供jar的启动速度。

java -jar -Xloggc:./gc-adjust-%t.log -XX:MetaspaceSize=256M -XX:MaxMetaspaceSize=256M -XX:+PrintGCDetails -XX:+PrintGCDateStamps   -XX:+PrintGCTimeStamps -XX:+PrintGCCause  -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=100M  microservice-eureka-server.jar

调整完我们再看下gc日志发现已经没有因为元空间不够导致的fullgc了

对于CMS和G1收集器的日志会有一点不一样，也可以试着打印下对应的gc日志分析下，可以发现gc日志里面的gc步骤跟我们之前讲过的步骤是类似的

public class HeapTest { 
    
        byte[] a = new byte[1024 * 100];  //100KB
    
        public static void main(String[] args) throws InterruptedException { 
            ArrayList<HeapTest> heapTests = new ArrayList<>();
            while (true) { 
                heapTests.add(new HeapTest());
                Thread.sleep(10);
            }
        }
    }

**CMS**

-Xloggc:d:/gc-cms-%t.log -Xms50M -Xmx50M -XX:MetaspaceSize=256M -XX:MaxMetaspaceSize=256M -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCTimeStamps -XX:+PrintGCCause -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=100M -XX:+UseParNewGC -XX:+UseConcMarkSweepGC

**G1**

-Xloggc:d:/gc-g1-%t.log -Xms50M -Xmx50M -XX:MetaspaceSize=256M -XX:MaxMetaspaceSize=256M -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCTimeStamps -XX:+PrintGCCause -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=100M -XX:+UseG1GC

上面的这些参数，能够帮我们查看分析GC的垃圾收集情况。但是如果GC日志很多很多，成千上万行。就算你一目十行，看完了，脑子也是一片空白。所以我们可以借助一些功能来帮助我们分析，这里推荐一个gceasy([https://gceasy.io][https_gceasy.io])，可以上传gc文件，然后他会利用可视化的界面来展现GC情况。具体下图所示

![0][0 51]

上图我们可以看到年轻代，老年代，以及永久代的内存分配，和最大使用情况。

![0][0 52]

上图我们可以看到堆内存在GC之前和之后的变化，以及其他信息。

这个工具还提供基于机器学习的JVM智能优化建议，当然现在这个功能需要付费

![0][0 53]

![0][0 54]

**JVM参数汇总查看命令**

--------------------

java -XX:+PrintFlagsInitial 表示打印出所有参数选项的默认值

java -XX:+PrintFlagsFinal 表示打印出所有参数选项在运行程序时生效的值

# 10.Class常量池与运行时常量池 #

--------------------

Class常量池可以理解为是Class文件中的资源仓库。 Class文件中除了包含类的版本、字段、方法、接口等描述信息外，还有一项信息就是**常量池(constant pool table)**，用于存放编译期生成的各种**字面量(Literal)和符号引用(Symbolic References)**。

一个class文件的16进制大体结构如下图：

![0][0 55]

对应的含义如下，细节可以查下oracle官方文档

![0][0 56]

当然我们一般不会去人工解析这种16进制的字节码文件，我们一般可以通过javap命令生成更可读的JVM字节码指令文件：

**javap -v Math.class**

![0][0 57]

红框标出的就是class常量池信息，常量池中主要存放两大类常量：**字面量和符号引用**。

**字面量**

**字面量就是指由字母、数字等构成的字符串或者数值常量**

字面量只可以右值出现，所谓右值是指等号右边的值，如：int a=1 这里的a为左值，1为右值。在这个例子中1就是字面量。

int a = 1; int b = 2; int c = “abcdefg”; int d = “abcdefg”;

**符号引用**

符号引用是编译原理中的概念，是相对于直接引用来说的。主要包括了以下三类常量：

*  类和接口的全限定名
 *  字段的名称和描述符
 *  方法的名称和描述符

上面的a，b就是字段名称，就是一种符号引用，还有Math类常量池里的 Lcom/tuling/jvm/Math 是类的全限定名，main和compute是方法名称，()是一种UTF8格式的描述符，这些都是符号引用。

这些常量池现在是静态信息，只有到运行时被加载到内存后，这些符号才有对应的内存地址信息，这些常量池一旦被装入内存就变成**运行时常量池**，对应的符号引用在程序加载或运行时会被转变为被加载到内存区域的代码的直接引用，也就是我们说的**动态链接了。例如，compute()这个符号引用在运行时就会被转变为compute()方法具体代码在内存中的地址，主要通过对象头里的类型指针去转换直接引用。**

**字符串常量池**

--------------------

**字符串常量池的设计思想**

1.  字符串的分配，和其他的对象分配一样，耗费高昂的时间与空间代价，作为最基础的数据类型，大量频繁的创建字符串，极大程度地影响程序的性能
2.  JVM为了提高性能和减少内存开销，在实例化字符串常量的时候进行了一些优化

*  为字符串开辟一个字符串常量池，类似于缓存区
 *  创建字符串常量时，首先查询字符串常量池是否存在该字符串
 *  存在该字符串，返回引用实例，不存在，实例化该字符串并放入池中

**三种字符串操作(Jdk1.7 及以上版本)**

**字符串常量池在堆里面**

*  直接赋值字符串

String s = "zhuge";  // s指向常量池中的引用

这种方式创建的字符串对象，只会在常量池中。

因为有"zhuge"这个字面量，创建对象s的时候，JVM会先去常量池中通过 equals(key) 方法，判断是否有相同的对象

如果有，则直接返回该对象在常量池中的引用；

如果没有，则会在常量池中创建一个新对象，再返回引用。

*  new String();

`String s1 = new String("zhuge"); // s1指向内存中的对象引用`

这种方式会保证字符串常量池和堆中都有这个对象，没有就创建，最后返回堆内存中的对象引用。

步骤大致如下：

因为有"zhuge"这个字面量，所以会先检查字符串常量池中是否存在字符串"zhuge"

不存在，先在字符串常量池里创建一个字符串对象；再去内存中创建一个字符串对象"zhuge"；

存在的话，就直接去堆内存中创建一个字符串对象"zhuge"；

最后，将内存中的引用返回。

*  intern方法

String s1 = new String("zhuge");  
    String s2 = s1.intern(); 
    System.out.println(s1 == s2);  //false

String中的intern方法是一个 native 的方法，当调用 intern方法时，如果池已经包含一个等于此String对象的字符串（用equals(oject)方法确定），则返回池中的字符串。**否则，将intern返回的引用指向当前字符串 s1**(**jdk1.6版本需要将 s1 复制到字符串常量池里**)。

**字符串常量池位置**

Jdk1.6及之前： 有永久代, 运行时常量池在永久代，运行时常量池包含字符串常量池

Jdk1.7：有永久代，但已经逐步“去永久代”，字符串常量池从永久代里的运行时常量池分离到堆里

**Jdk1.8及之后： 无永久代，运行时常量池在元空间，字符串常量池里依然在堆里**

用一个程序证明下字符串常量池在哪里：

/\*\* \* jdk6：-Xms6M -Xmx6M -XX:PermSize=6M -XX:MaxPermSize=6M \* jdk8：-Xms6M -Xmx6M -XX:MetaspaceSize=6M -XX:MaxMetaspaceSize=6M \*/ public class RuntimeConstantPoolOOM\{ public static void main(String\[\] args) \{ ArrayList list = new ArrayList(); for (int i = 0; i < 10000000; i++) \{ String str = String.valueOf(i).intern(); list.add(str); \} \} \} 运行结果： jdk7及以上：Exception in thread “main” java.lang.OutOfMemoryError: Java heap space jdk6：Exception in thread “main” java.lang.OutOfMemoryError: PermGen space

**字符串常量池设计原理**

字符串常量池底层是hotspot的C++实现的，底层类似一个 HashTable， 保存的本质上是字符串对象的引用。

看一道比较常见的面试题，下面的代码创建了多少个 String 对象？

String s1 = new String("he") + new String("llo"); 
    String s2 = s1.intern();  
    System.out.println(s1 == s2); // 在 JDK 1.6 下输出是 false，创建了 6 个对象 // 在 JDK 1.7 及以上的版本输出是 true，创建了 5 个对象 // 当然我们这里没有考虑GC，但这些对象确实存在或存在过

为什么输出会有这些变化呢？主要还是字符串池从永久代中脱离、移入堆区的原因， intern() 方法也相应发生了变化：

1、在 JDK 1.6 中，调用 intern() 首先会在字符串池中寻找 equal() 相等的字符串，假如字符串存在就返回该字符串在字符串池中的引用；假如字符串不存在，虚拟机会重新在永久代上创建一个实例，将 StringTable 的一个表项指向这个新创建的实例。

![0][0 58]

2、在 JDK 1.7 (及以上版本)中，由于字符串池不在永久代了，intern() 做了一些修改，更方便地利用堆中的对象。字符串存在时和 JDK 1.6一样，但是字符串不存在时不再需要重新创建实例，可以直接指向堆上的实例。

![0][0 59]

由上面两个图，也不难理解为什么 JDK 1.6 字符串池溢出会抛出 OutOfMemoryError: PermGen space ，而在 JDK 1.7 及以上版本抛出 OutOfMemoryError: Java heap space 。

**String常量池问题的几个例子**

示例1：

String s0="zhuge";
    String s1="zhuge";
    String s2="zhu" + "ge";
    System.out.println( s0==s1 ); //true
    System.out.println( s0==s2 ); //true

分析：因为例子中的 s0和s1中的”zhuge”都是字符串常量，它们在编译期就被确定了，所以s0s1为true；而”zhu”和”ge”也都是字符串常量，当一个字 符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被优化为一个字符串常量"zhuge"，所以s2也是常量池中” zhuge”的一个引用。所以我们得出s0s1==s2；

示例2：

String s0="zhuge";
    String s1=new String("zhuge");
    String s2="zhu" + new String("ge");
    System.out.println( s0==s1 );　　// false
    System.out.println( s0==s2 )；　 // false
    System.out.println( s1==s2 );　　// false

分析：用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

s0还是常量池 中"zhuge”的引用，s1因为无法在编译期确定，所以是运行时创建的新对象”zhuge”的引用，s2因为有后半部分 new String(”ge”)所以也无法在编译期确定，所以也是一个新创建对象”zhuge”的引用;明白了这些也就知道为何得出此结果了。

示例3：

String a = "a1";
      String b = "a" + 1;
      System.out.println(a == b); // true 
      
      String a = "atrue";
      String b = "a" + "true";
      System.out.println(a == b); // true 
      
      String a = "a3.4";
      String b = "a" + 3.4;
      System.out.println(a == b); // true

分析：JVM对于字符串常量的"+“号连接，将在程序编译期，JVM就将常量字符串的”+“连接优化为连接后的值，拿"a” + 1来说，经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。

示例4：

String a = "ab";
    String bb = "b";
    String b = "a" + bb;
    
    System.out.println(a == b); // false

分析：JVM对于字符串引用，由于在字符串的"+“连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a” + bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b。所以上面程序的结果也就为false。

示例5：

String a = "ab";
    final String bb = "b";
    String b = "a" + bb;
    
    System.out.println(a == b); // true

分析：和示例4中唯一不同的是bb字符串加了final修饰，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的"a" + bb和"a" + "b"效果是一样的。故上面程序的结果为true。

示例6：

String a = "ab";
    final String bb = getBB();
    String b = "a" + bb;
    
    System.out.println(a == b); // false
    
    private static String getBB() 
    {   
        return "b";  
     }

分析：JVM对于字符串引用bb，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"a"来动态连接并分配地址为b，故上面 程序的结果为false。

**关于String是不可变的**

通过上面例子可以得出得知：

String  s  =  "a" + "b" + "c";  //就等价于String s = "abc";
    String  a  =  "a";
    String  b  =  "b";
    String  c  =  "c";
    String  s1  =   a  +  b  +  c;

s1 这个就不一样了，可以通过观察其**JVM指令码**发现s1的"+"操作会变成如下操作：

StringBuilder temp = new StringBuilder();
    temp.append(a).append(b).append(c);
    String s = temp.toString();

**最后再看一个例子**：

//字符串常量池："计算机"和"技术" 堆内存：str1引用的对象"计算机技术" 
    //堆内存中还有个StringBuilder的对象，但是会被gc回收，StringBuilder的toString方法会new String()，这个String才是真正返回的对象引用
    String str2 = new StringBuilder("计算机").append("技术").toString();   //没有出现"计算机技术"字面量，所以不会在常量池里生成"计算机技术"对象
    System.out.println(str2 == str2.intern());  //true
    //"计算机技术" 在池中没有，但是在heap中存在，则intern时，会直接返回该heap中的引用
    
    //字符串常量池："ja"和"va" 堆内存：str1引用的对象"java" 
    //堆内存中还有个StringBuilder的对象，但是会被gc回收，StringBuilder的toString方法会new String()，这个String才是真正返回的对象引用
    String str1 = new StringBuilder("ja").append("va").toString();    //没有出现"java"字面量，所以不会在常量池里生成"java"对象
    System.out.println(str1 == str1.intern());  //false
    //java是关键字，在JVM初始化的相关类里肯定早就放进字符串常量池了
    
    String s1=new String("test");  
    System.out.println(s1==s1.intern());   //false
    //"test"作为字面量，放入了池中，而new时s1指向的是heap中新生成的string对象，s1.intern()指向的是"test"字面量之前在池中生成的字符串对象
    
    String s2=new StringBuilder("abc").toString();
    System.out.println(s2==s2.intern());  //false
    //同上

**八种基本类型的包装类和对象池**

--------------------

java中基本类型的包装类的大部分都实现了常量池技术(严格来说应该叫\*\*对象池，\*\*在堆上)，这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类则没有实现。另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池，也即对象不负责创建和管理大于127的这些类的对象。因为一般这种比较小的数用到的概率相对较大。

public class Test { 
    
        public static void main(String[] args) { 
            //5种整形的包装类Byte,Short,Integer,Long,Character的对象， 
            //在值小于127时可以使用对象池 
            Integer i1 = 127;  //这种调用底层实际是执行的Integer.valueOf(127)，里面用到了IntegerCache对象池
            Integer i2 = 127;
            System.out.println(i1 == i2);//输出true 
    
            //值大于127时，不会从对象池中取对象 
            Integer i3 = 128;
            Integer i4 = 128;
            System.out.println(i3 == i4);//输出false 
            
            //用new关键词新生成对象不会使用对象池
            Integer i5 = new Integer(127);  
            Integer i6 = new Integer(127);
            System.out.println(i5 == i6);//输出false 
    
            //Boolean类也实现了对象池技术 
            Boolean bool1 = true;
            Boolean bool2 = true;
            System.out.println(bool1 == bool2);//输出true 
    
            //浮点类型的包装类没有实现对象池技术 
            Double d1 = 1.0;
            Double d2 = 1.0;
            System.out.println(d1 == d2);//输出false 
        }
    }

文档：08-VIP-JVM调优实战及常量池详解

http://note.youdao.com/noteshare?id=d8d6dc3589ffd9245d97bb7aa91af835&sub=AD9BB50E218B455B9327FC86856F9942

[0]: /images/20221119/c0bb31fa575c4d06b7fa81047cb9ddb7.png
[0 1]: https://img-blog.csdnimg.cn/img_convert/087375d1507aece6d68e80a895c8c9de.png
[0 2]: https://img-blog.csdnimg.cn/img_convert/dbc59a830433312b35ec243779b2c230.png
[0 3]: https://img-blog.csdnimg.cn/img_convert/63d63c3fc29f81c5199c1aeaa45a1cbe.png
[0 4]: https://img-blog.csdnimg.cn/img_convert/0958df3d12fed00a01a14aa23ebca454.png
[0 5]: https://img-blog.csdnimg.cn/img_convert/00c833a3bbd3ddcb963c9d36759bb6cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210127161648217.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg==,size_16,color_FFFFFF,t_70
[0 6]: https://img-blog.csdnimg.cn/img_convert/34864b53357a65af148a03989cbd3b42.png
[0 7]: https://img-blog.csdnimg.cn/img_convert/80074b0829620ebb3b118aaffadc89f9.png
[0 8]: https://img-blog.csdnimg.cn/img_convert/8cb8335490a49582e84b526b80d4c715.png
[0 9]: https://img-blog.csdnimg.cn/img_convert/50131ded9a5eeb8cef1655e9759afdf9.png
[0 10]: https://img-blog.csdnimg.cn/img_convert/abf58ae6b806979f9111a6a8efa323f2.png
[0 11]: https://img-blog.csdnimg.cn/img_convert/a2e83b464e49c0a51e7056aa076c77c2.png
[0 12]: https://img-blog.csdnimg.cn/img_convert/66f8a5a5b12ec15278ef9c300c5bb485.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210130212132613.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg==,size_16,color_FFFFFF,t_70
[0 13]: https://img-blog.csdnimg.cn/img_convert/220efbb0280e6535af097f4d2a2361b4.png
[0 14]: https://img-blog.csdnimg.cn/img_convert/9be3fe5bf00be8872cf41d7237cef506.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210130212119171.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/202101302120539.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg==,size_16,color_FFFFFF,t_70
[0 15]: https://img-blog.csdnimg.cn/img_convert/cf8c5e815adc502b47de3ed9f4d7538c.png
[0 16]: https://img-blog.csdnimg.cn/img_convert/266629052eb3863ae8e40d5db8b871c6.png
[0 17]: https://img-blog.csdnimg.cn/img_convert/320eed3536c0987f7afd12ecba1da494.png
[0 18]: https://img-blog.csdnimg.cn/img_convert/096b50077c6bf5a59d00dbd0ae058736.png
[0 19]: https://img-blog.csdnimg.cn/img_convert/c2d2faccbc0b9f1c0c27474cd482974d.png
[0 20]: https://img-blog.csdnimg.cn/img_convert/7fa724148c54cb64b57b112a239e599e.png
[0 21]: https://img-blog.csdnimg.cn/img_convert/15a42d6ce33e7670eb31799ac9facc89.png
[0 22]: https://img-blog.csdnimg.cn/img_convert/e07dbfcb068cd4d700e01db603215f4d.png
[0 23]: https://img-blog.csdnimg.cn/img_convert/9766ef3a8e996c78c5f42a43adce77de.png
[0 24]: https://img-blog.csdnimg.cn/img_convert/4a832d3a2195c563af533fb035102f84.png
[0 25]: https://img-blog.csdnimg.cn/img_convert/bedd01523d3dda1a427663fae0dda2d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210201160940806.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210201161015408.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210201161228212.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg==,size_16,color_FFFFFF,t_70
[0 26]: https://img-blog.csdnimg.cn/img_convert/79937a75a4875d73ce08c666e0dd42ed.png
[0 27]: https://img-blog.csdnimg.cn/img_convert/c3f3a1bbe0cb8d2ec9973b634c761580.png
[20210202110206149.png]: https://img-blog.csdnimg.cn/20210202110206149.png
[0 28]: https://img-blog.csdnimg.cn/img_convert/c3cc9efd128eb391ef0a78002851c21f.png
[20210201170756261.png]: https://img-blog.csdnimg.cn/20210201170756261.png
[0 29]: https://img-blog.csdnimg.cn/img_convert/244f62ce08464620ab9b1a25aeb9a260.png
[0 30]: https://img-blog.csdnimg.cn/img_convert/fb93e61e2a63f6da7693c3acb1d5681e.png
[0 31]: https://img-blog.csdnimg.cn/img_convert/7ac5df8809ab2e607afb538e37939b24.png
[0 32]: https://img-blog.csdnimg.cn/img_convert/be925a810ed958945579002374183bbc.png
[0 33]: https://img-blog.csdnimg.cn/img_convert/f6b6cdbc926738e942e7839e1873664b.png
[0 34]: https://img-blog.csdnimg.cn/img_convert/a834bb1bd52a6d736ac5a5f74b48ece5.png
[0 35]: https://img-blog.csdnimg.cn/img_convert/a8e656238add250900824da56bcce185.png
[0 36]: https://img-blog.csdnimg.cn/img_convert/71b2af3fc9bf7e7987323d5ab80b3c60.png
[0 37]: https://img-blog.csdnimg.cn/img_convert/6a32f1354693bca9f8e880a3a30d2849.png
[0 38]: https://img-blog.csdnimg.cn/img_convert/e6ee5ecbfeba16fd6fee9ddf29d851c5.png
[0 39]: https://img-blog.csdnimg.cn/img_convert/cbfb8082edbea9f782d3e6cf2942c7ec.png
[0 40]: https://img-blog.csdnimg.cn/img_convert/c502f62b641ce118f887ed3ddab880dc.png
[https_alibaba.github.io_arthas]: https://alibaba.github.io/arthas
[0 41]: https://img-blog.csdnimg.cn/img_convert/e82da0e8a2e258027100f935ae31fe07.png
[0 42]: https://img-blog.csdnimg.cn/img_convert/bc36460617a98236f15b982a3ac1fe21.png
[0 43]: https://img-blog.csdnimg.cn/img_convert/26a3b03fcd0074be9345be32c7de06c0.png
[0 44]: https://img-blog.csdnimg.cn/img_convert/d137a4a905a71a9efbbb4046acb83b59.png
[0 45]: https://img-blog.csdnimg.cn/img_convert/7fafb4f057bddce5f77f32df06e786ac.png
[0 46]: https://img-blog.csdnimg.cn/img_convert/c10dda236018a50da12371fe3f97b95f.png
[0 47]: https://img-blog.csdnimg.cn/img_convert/ea81b0680c4bfec9e1d041c0ce170f70.png
[0 48]: https://img-blog.csdnimg.cn/img_convert/f090737eb34840c82789634671be8220.png
[0 49]: https://img-blog.csdnimg.cn/img_convert/5fb38a43651227b00446f56e29fd3d14.png
[0 50]: https://img-blog.csdnimg.cn/img_convert/05e0b8b79fe0e76458efc32e483841f4.png
[https_gceasy.io]: https://gceasy.io/
[0 51]: https://img-blog.csdnimg.cn/img_convert/e9a28c299b5a5d83abafe2a0f15b5cb2.png
[0 52]: https://img-blog.csdnimg.cn/img_convert/d9497eda0308df99ab2acdf1ea34ede3.png
[0 53]: https://img-blog.csdnimg.cn/img_convert/ba8cfa3595c25ec76d5cd28129182261.png
[0 54]: /images/20221119/7da6a8f7f3a44978bc34ed66a5f98837.png
[0 55]: https://img-blog.csdnimg.cn/img_convert/9857562649a093541ca7a3e7c4fa844f.png
[0 56]: https://img-blog.csdnimg.cn/img_convert/ef52c76304c76970a36c292806a6735f.png
[0 57]: https://img-blog.csdnimg.cn/img_convert/0d1651b4d08d9ca7f32427ff59098b11.png
[0 58]: https://img-blog.csdnimg.cn/img_convert/8cf1f57879c71421329dbf28ccb1b337.png
[0 59]: https://img-blog.csdnimg.cn/img_convert/a2b0e168e180b01812360e4c5b868902.png