README.md · 起床，何爵为/jvm

- [1、我们平时写的Java代码，到底是怎么运行起来的？](#1-我们平时写的java代码到底是怎么运行起来的)

- [2、 JVM类加载过程](#2-JVM类加载过程)

- [3、 JVM类加载机制](#3-JVM类加载机制)

- [4、 JVM内存划分](#4-JVM内存划分)

- [5、 JVM垃圾回收是什么](#5-JVM垃圾回收是什么)

- [6、 JVM中可分配内存&内存如何分配](#6-JVM中可分配内存内存如何分配)

- [7、什么对象会被回收](#7-什么对象会被回收)

- [8、minorGC针对新生代的垃圾回收&算法，复制算法](#8-minorgc针对新生代的垃圾回收算法复制算法)

- [9、对象新生代穿越到老年代](#9-对象新生代穿越到老年代)

- [10、老年代接收对象](#10-老年代接收对象)

- [11、老年代的垃圾回收算法，标记整理算法](#11-老年代的垃圾回收算法标记整理算法)

- [12、stopTheWorld](#12-stopTheWorld)
 
- [13、G1垃圾回收器](#13-G1垃圾回收器)

- [14、G1新生代+老年代的混合垃圾回收](#14-G1新生代老年代的混合垃圾回收)

- [15、各垃圾回收器的比较](#15-各垃圾回收器的比较)

- [16、jstat摸清jvm](#16-jstat摸清jvm)

- [17、jmap和jhat摸清线上系统的对象分布](#17-jmap和jhat摸清线上系统的对象分布)

- [18、cpu过高分析](#18-cpu过高分析)

- [19、MAT](#19-mat)

- [20、OOM内存溢出](#20-OOM内存溢出)

- [21、tomcat](#21-tomcat)

- [99、案例分析](#99-案例分析)

- [一、每日百万交易支付系统，如何设置内存？](#一-每日百万交易支付系统如何设置内存)

- [二、一个日处理上亿数据的计算系统](#二-一个日处理上亿数据的计算系统)

- [三、每日上亿请求量的电商系统](#三-每日上亿请求量的电商系统)

- [四、百万级用户的在线教育平台，如何基于G1垃圾回收器优化性能](#四-百万级用户的在线教育平台如何基于G1垃圾回收器优化性能)

- [五、每秒10万并发的BI系统是如何频繁发生YoungGC的？](#五-每秒10万并发的BI系统是如何频繁发生YoungGC的)

- [六、每秒十万QPS的社交APP,如何优化GC性能提升3倍？](#六-每秒十万QPS的社交APP如何优化GC性能提升3倍)

### 1、 我们平时写的java代码，到底是怎么运行起来的

对于编译好的这些“.class”字节码，是怎么让他们运行起来的呢？

这个时候就需要使用诸如“java -jar”之类的命令来运行我们写好的代码了。

此时一旦你采用“java”命令，实际上此时就会启动一个JVM进程。

这个JVM就会来负责运行这些“.class”字节码文件，也就相当于是负责运行我们写好的系统。

所以平时我们写好的某个系统在一台机器上部署的时候，你一旦启动这个系统，其实就是启动了一个JVM，由它来负责运行这台机器上运行的这个系统。

![](picture/1、JVM是什麽.jpg)

### 2、 JVM类加载过程

一个类从加载到使用，一般会经历下面的这个过程：

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

1、加载：你的代码中用到这个类的时候->会从“.class”字节码文件中加载这个类到JVM内存里来。

2、验证:简单来说，这一步就是根据Java虚拟机规范，来校验你加载进来的“.class”文件中的内容，是否符合指定的规范。

3、准备：给类分配一定的内存空间，然后给类里面的类变量（也就是static修饰的变量）分配内存空间，来一个默认的初始值。

4、解析：是把符号引用替换为直接引用的过程，其实这个部分的内容很复杂，涉及到JVM的底层

5、初始化：给类的属性赋值，执行类的构造函数，执行类静态方法，发现他的父类还没初始化，那么必须先初始化他的父类。

![](picture/2、JVM类加载过程.png)

栗子：

![](picture/3、类加载.jpeg)
![](picture/4、类加载.jpeg)

1、JVM进程启动之后，它一定会先把你的这个类（Kafka.cass）加载到内存里，然后从“main()”方法的入口代码开始执行。

2、触发JVM通过类加载器，从“ReplicaManager.class”字节码文件中加载对应的类到内存里来使用，这样代码才能跑起来。

3、给这个“ReplicaManager”类分配一定的内存空间，给“flushInterval”这个类变量分配内容空间，给一个“0”这个初始值。

4、是把符号引用替换为直接引用。

5、就会执行类的初始化代码，比如上面的  Configuration.getInt("replica.flush.interval")  代码就会在这里执行，完成一个配置项的读
取，然后赋值给这个类变量“flushInterval”。执行static静态代码块，调用“loadReplicaFromDish()”方法从磁盘中加载数据副本，并且放在静
态变量“replicas”。发现他的父类还没初始化，那么必须先初始化他的父类。

比如“new ReplicaManager()”来实例化类的对象了，此时就会触发类的加载到初始化的全过程，把这个类准备好，然后再实例化一个对象出来；

### 3、 JVM类加载机制

3.1、双亲委派

Java里有哪些类加载器呢?

![](picture/5、类加载器.png)

启动类加载器:Bootstrap ClassLoader，他主要是负责加载我们在机器上安装的Java目录下的核心类的,一旦你的JVM启动，那么首先就会依托启动
类加载器，去加载你的Java安装目录下的“lib”目录中的核心类库。

扩展类加载器:Extension ClassLoader，这个类加载器其实也是类似的，就是你的Java安装目录下，有一个“lib\ext”目录这里面有一些类，就是
需要使用这个类加载器来加载的，支撑你的系统的运行。那么你的JVM一旦启动，是不是也得从Java安装目录下，加载这个“lib\ext”目录中的类？

应用程序类加载器:Application ClassLoader，这类加载器就负责去加载“ClassPath”环境变量所指定的路径中的类，其实你大致就理解为去加载
你写好的Java代码吧，这个类加载器就负责加载你写好的那些类到内存里。

自定义类加载器:除了上面那几种之外，还可以自定义类加载器，去根据你自己的需求加载你的类。

就是假设你的应用程序类加载器需要加载一个类，他首先会委派给自己的父类加载器去加载，最终传导到顶层的类加载器去加载，但是如果父类加载
器在自己负责加载的范围内，没找到这个类，那么就会下推加载权利给自己的子类加载器。

栗子：

![](picture/6、双亲委派加载.png)

### 4、 JVM内存划分

1、Metaspace：“元数据空间”这样的意思。当然这里主要还是存放我们自己写的各种类相关的信息。

2、程序计数器：编译器，把“.java”后缀的源代码文件编译为“.class”后缀的字节码文件。当JVM加载类信息到内存之后，实际就会使用自己的字节
码执行引擎，去执行我们写的代码编译出来的代码指令。执行字节码指令的时候，JVM里就需要一个特殊的内存区域了，那就是“程序计数器”。用来记
录当前执行的字节码指令的位置的，也就是记录目前执行到了哪一条字节码指令。
JVM是支持多个线程的，所以其实你写好的代码可能会开启多个线程并发执行不同的代码，所以就会有多个线程来并发的执行不同的代码指令，因此每
个线程都会有自己的一个程序计数器，专门记录当前这个线程目前执行到了哪一条字节码指令了。

3、Java虚拟机栈：JVM必须有一块区域是来保存每个方法内的局部变量等数据的，这个区域就是Java虚拟机栈，每个线程都有自己的Java虚拟机栈，
比如这里的main线程就会有自己的一个Java虚拟机栈，用来存放自己执行的那些方法的局部变量。如果线程执行了一个方法，就会对这个方法调用创
建对应的一个栈帧。栈帧里就有这个方法的局部变量表 、操作数栈、动态链接、方法出口等东西。每个线程在执行代码时，除了程序计数器以外，还
搭配了一个Java虚拟机栈内存区域来存放每个方法中的局部变量表。

4、Java堆内存：存放我们在代码中创建的各种对象。虚拟机栈里面的属性，会把应用指向这里的一个个对象。

5、其他内存区域：native方法的时候，就会有线程对应的本地方法栈，这个里面也是跟Java虚拟机栈类似的，也是存放各种native方法的局部变量
表之类的信息。通过NIO中的allocateDirect这种API，可以在Java堆外分配内存空间。然后，通过Java虚拟机里的DirectByteBuffer来引用和操
作堆外内存空间。

![](picture/7、JVM内存划分.png)

main线程在执行main()方法的时候，会在main线程关联的Java虚拟机栈里，压入一个main()方法的栈帧。接着会发现需要创建一个ReplicaManager
类的实例对象，此时会加载ReplicaManager、类到内存里来。然后会创建一个ReplicaManager的对象实例分配在Java堆内存里，并且在main()方
法的栈帧里的局部变量表引入一个“replicaManager”变量，让他引用ReplicaManager对象在Java堆内存中的地址。

### 5、 JVM垃圾回收是什么

JVM本身是有垃圾回收机制的，他是一个后台自动运行的线程

你只要启动一个JVM进程，他就会自带这么一个垃圾回收的后台线程。

这个线程会在后台不断检查JVM堆内存中的各个实例对象

如果某个实例对象没有任何一个方法的局部变量指向他，也没有任何一个类的静态变量，包括常量等地方在指向他。

那么这个垃圾回收线程，就会把这个没人指向的“ReplicaManager”实例对象给回收掉，从内存里清除掉，让他不再占用任何内存资源。

这样的话，这些不再被人指向的对象实例，即JVM中的“垃圾”，就会定期的被后台垃圾回收线程清理掉，不断释放内存资源。

### 6、 JVM中可分配内存&内存如何分配

![](picture/8、分配内存.png)

-Xms：Java堆内存的大小

-Xmx：Java堆内存的最大大小

-Xmn：Java堆内存中的新生代大小，扣除新生代剩下的就是老年代的内存大小了

-XX:PermSize：永久代大小

-XX:MaxPermSize：永久代最大大小

-Xss：每个线程的栈内存大小

### 7、 什么对象会被回收

JVM中使用了一种可达性分析算法来判定哪些对象是可以被回收的，哪些对象是不可以被回收的。

这个算法的意思，就是说对每个对象，都分析一下有谁在引用他，然后一层一层往上去判断，看是否有一个GC Roots。

在JVM规范中，局部变量就是可以作为GC Roots的。

只要一个对象被局部变量引用了，那么就说明他有一个GC Roots，此时就不能被回收了。

此时在JVM的规范里，静态变量也可以看做是一种GC Roots，此时只要一个对象被GC Roots引用了，就不会去回收他。

一句话总结：只要你的对象被方法的局部变量、类的静态变量给引用了，就不会回收他们。

Java里有不同的引用类型：分别是强引用、软引用、弱引用和虚引用。

强引用：

![](./picture/9、强引用.png)

这个就是最普通的代码，一个变量引用一个对象，只要是强引用的类型，那么垃圾回收的时候绝对不会去回收这个对象的。

软引用:

![](./picture/10、软引用.png)

正常情况下垃圾回收是不会回收软引用对象的，但是如果你进行垃圾回收之后，发现内存空间还是不够存放新的对象，内存都快溢出了
此时就会把这些软引用对象给回收掉，哪怕他被变量引用了，但是因为他是软引用，所以还是要回收。

弱引用:

![](./picture/11、弱引用.png)

这个其实非常好解释，你这个弱引用就跟没引用是类似的，如果发生垃圾回收，就会把这个对象回收掉。

finalize():

![](./picture/12、finalize().png)

假设有一个ReplicaManager对象要被垃圾回收了，那么假如这个对象重写了Object类中的finialize()方法 此时会先尝试调用一下他
的finalize()方法，看是否把自己这个实例对象给了某个GCRoots变量，比如说代码中就给了ReplicaManager类的静态变量。 如果重新让某个
GC Roots变量引用了自己，那么就不用被垃圾回收了。

### 8、 minorGC针对新生代的垃圾回收&算法，复制算法

通过把存活对象先转移到另外一块空白内存区域，我们可以把这些对象都比较紧凑的排列在内存里这样就可以让被转移的那块内存区域几乎没有什么内
存碎片，对象都是按顺序排列在这块内存里的。然后那块被转移的内存区域，是不是多出来一大块连续的可用的内存空间？此时就可以将新对象分配在
那块连续内存空间里了。

这个时候，再一次性把原来使用的那块内存区域中的垃圾对象全部一扫而空，全部给回收掉，空出来一块内存区域，这就是所谓的“复制算法“，把新生
代内存划分为两块内存区域，然后只使用其中一块内存待那块内存快满的时候，就把里面的存活对象一次性转移到另外一块内存区域，保证没有内存碎
片。接着一次性回收原来那块内存区域的垃圾对象，再次空出来一块内存区域。两块内存区域就这么重复着循环使用。

![](./picture/13、复制算法.png)

![](./picture/14、垃圾回收-复制算法.png)

### 9、 对象新生代穿越到老年代

1、自然进入老年代：
对象每次在新生代里躲过一次GC被转移到一块Survivor区域中，此时他的年龄就会增长一岁，默认的设置下，当对象的年龄达到
15岁的时候，也就是躲过15次GC的时候，他就会转移到老年代里去。可以通过JVM参数“-XX:MaxTenuringThreshold”来设置，默认是15岁。

2、动态对象年龄判断：
当前放对象的Survivor区域里，一批对象的总大小大于了这块Survivor区域的内存大小的50%，那么此时大于等于这批对象年龄的对象，就可以直接进
入老年代了。（对象1+对象2+对象3+..）>当前survivor50%。年龄大于对象1,2,3.....的对象全部进入老年代。

3、大对象直接进入老年代：
有一个JVM参数，就是“-XX:PretenureSizeThreshold”，可以把他的值设置为字节数，比如“1048576”字节，就是1MB。他的意思就是，如果你要创建
一个大于这个大小的对象，比如一个超大的数组，或者是别的啥东西，此时就直接把这个大对象放到老年代里去。压根儿不会经过新生代。

4、Minor GC后的对象太多无法放入Survivor区：
这个时候就必须得把这些对象直接转移到老年代去。

### 10、 老年代接收对象

1、老年代空间分配担保规则：
首先，在执行任何一次Minor GC之前，JVM会先检查一下老年代的可用内存空间，是否大于新生代所有对象的总大小。发现老年代的内存大小是大
于新生代所有对象的，此时就可以放心大胆的对新生代发起一次Minor GC了，因为即使Minor GC之后所有对象都存活，Survivor区放不下了，也可以
转移到老年代去。

2、当老年代可用空间 < 新生代所有对象大小:

![](./picture/15、老年代空间吃紧.png)

【设置了-XX:-HandlePromotionFailure】就会查看老年代的内存大小，是否大于之前每一次Minor GC后进入老年代的对象的平均大小。

![](./picture/16、HandlePromotionFailure.png)

第一种可能，Minor GC过后，剩余的存活对象的大小，是小于Survivor区的大小的，那么此时存活对象进入Survivor区域即可。

第二种可能，Minor GC过后，剩余的存活对象的大小，是大于 Survivor区域的大小，但是是小于老年代可用内存大小的，此时就直接进入老年代即可。

第三种可能，很不幸，Minor GC过后，剩余的存活对象的大小，大于了Survivor区域的大小，也大于了老年代可用内存的大小。此时老年代都放不下这
些存活对象了，就会发生“Handle Promotion Failure”的情况，这个时候就会触发一次“Full GC”。

【没设置-XX:-HandlePromotionFailure】，就会直接出发“Full GC”。

![](./picture/17、没设参数.png)

如果要是Full GC过后，老年代还是没有足够的空间存放Minor GC过后的剩余存活对象，那么此时就会导致所谓的“OOM”内存溢出了。

### 11、 老年代的垃圾回收算法，标记整理算法

![](./picture/18、初探标记整理算法.png)

这个老年代的垃圾回收算法的速度至少比新生代的垃圾回收算法的速度慢10倍。

如果系统频繁出现老年代的Full GC垃圾回收，会导致系统性能被严重影响，出现频繁卡顿的情况。

![](./picture/24、cms-标记-清理算法.png)

老年代的CMS采用“标记-清理”算法，每次都是标记出来垃圾对象，然后一次性回收掉，这样会导致大量的内存碎片产生。如果内存碎片太多，会导致后
续对象进入老年代找不到可用的连续内存空间了，然后触发Full GC。所以CMS不是完全就仅仅用“标记-清理”算法的，因为太多的内存碎片实际上会导
致更加频繁的Full GC。在Full GC之后要再次进行“Stop the World”，停止工作线程，然后进行碎片整理，就是把存活对象挪到一起，空出来大片
连续内存空间，避免内存碎片。

### 12、 stopTheWorld

“Stop the World”会对系统造成的影响了， 假设我们的Minor GC要运行100ms，那么可能就会导致我们的系统直接停顿100ms不能处理任何请求在这
100ms期间用户发起的所有请求都会出现短暂的卡顿，因为系统的工作线程不在运行，不能处理请求。

![](./picture/23、parnew.png)

新生代我们会用ParNew垃圾回收器来进行回收，然后ParNew垃圾回收器针对新生代采用的就是复制算法来垃圾回收。我们的系统暂停运行，然后不再
创建新的对象，同时让垃圾回收线程尽快完成垃圾回收的工作，就是标记和转移Eden以及Survivor2的存活对象到Survivor1中去，然后尽快一次性回
收掉Eden和Survivor2中的垃圾对象。

### 13、 G1垃圾回收器

而且G1最大的一个特点，就是可以让我们设置一个垃圾回收的预期停顿时间

也就是说比如我们可以指定：希望G1同志在垃圾回收的时候，可以保证，在1小时内由G1垃圾回收导致的“Stop the World”时间，也就是系统停顿的时
间，不能超过1分钟。

这个就很厉害了，大家如果看明白了之前我们的很多JVM优化的思路，都明白一点，其实我们对内存合理分配，优化一些参数，就是为了尽可能减少
Minor GC和Full GC，尽量减少GC带来的系统停顿，避免影响系统处理请求。

G1垃圾回收器是可以同时回收新生代和老年代的对象的，不需要两个垃圾回收器配合起来运作，他一个人就可以搞定所有的垃圾回收。

他最大的一个特点，就是把Java堆内存拆分为多个大小相等的Region。

然后G1也会有新生代和老年代的概念，但是只不过是逻辑上的概念。而且G1最大的一个特点，就是可以让我们设置一个垃圾回收的预期停顿时间。

因为JVM最多可以有2048个Region，然后Region的大小必须是2的倍数，比如说1MB、2MB、4MB之类的。

系统运行中，JVM其实会不停的给新生代增加更多的Region，但是最多新生代的占比不会超过60%，可以通过“-XX:G1MaxNewSizePercent”。

而且一旦Region进行了垃圾回收，此时新生代的Region数量还会减少，这些其实都是动态的。

随着不停的在新生代的Eden对应的Region中放对象，JVM就会不停的给新生代加入更多的Region，直到新生代占据堆大小的最大比例60%。

一旦新生代达到了设定的占据堆内存的最大大小60%，比如都有1200个Region了，里面的Eden可能占据了1000个Region，每个Survivor是100个
Region，而且Eden区还占满了对象。

这个时候还是会触发新生代的GC，G1就会用之前说过的复制算法来进行垃圾回收，进入一个“Stop the World”状态

![](./picture/29、G1eden满.png)

然后把Eden对应的Region中的存活对象放入S1对应的Region中，接着回收掉Eden对应的Region中的垃圾对象

![](./picture/28、G1分布.png)

G1提供了专门的Region来存放大对象，而不是让大对象进入老年代的Region中。

按照默认新生代最多只能占据堆内存60%的Region来推算，老年代最多可以占据40%的Region，大概就是800个左右的Region。

（1）对象在新生代躲过了很多次的垃圾回收，达到了一定的年龄了，“-XX:MaxTenuringThreshold”参数可以设置这个年龄，他就会进入老年代。

（2）动态年龄判定规则，如果一旦发现某次新生代GC过后，存活对象超过了Survivor的50%。

### 14、 G1新生代+老年代的混合垃圾回收

G1有一个参数，是“-XX:InitiatingHeapOccupancyPercent”，他的默认值是45%，意思就是说，如果老年代占据了堆内存的45%的Region的时候，
此时就会尝试触发一个新生代+老年代一起回收的混合回收阶段。

![](./picture/30、混合回收.png)

“-XX:G1MixedGCCountTarget”参数，就是在一次混合回收的过程中，最后一个阶段执行几次混合回收，默认值是8次。

意味着最后一个阶段，先停止系统运行，混合回收一些Region，再恢复系统运行，接着再次禁止系统运行，混合回收一些Region，反复8次。

假设一次混合回收预期要回收掉一共有160个Region，那么此时第一次混合回收，会回收掉一些Region，比如就是 20个Region。

接着恢复系统运行一会儿，然后再执行一次“混合回收”，如下图，再次回收掉20个Region。

如此反复执行8次混合回收阶段之后 ，不就把预订的160个Region都回收掉了？而且还把系统停顿时间控制在指定范围内。

那么为什么要反复回收多次呢？

因为你停止系统一会儿，回收掉一些Region，再让系统运行一会儿，然后再次停止系统一会儿，再次回收掉一些Region，这样可以尽可能让系统不要停
顿时间过长，可以在多次回收的间隙，也运行一下。

“-XX:G1HeapWastePercent”，默认值是5%，他的意思就是说，在混合回收的时候，对Region回收都是基于复制算法进行的，都是把要回收的Region
里的存活对象放入其他Region，然后这个Region中的垃圾对象全部清理掉。

这样的话在回收过程就会不断空出来新的Region，一旦空闲出来的Region数量达到了堆内存的5%，此时就会 立即停止混合回收，意味着本次混合回收
就结束了。

-XX:G1MixedGCLiveThresholdPercent”，他的默认值是85%，意思就是确定要回收的Region的时候，必须是存活对象低于85%的Region才可以进行
回收。

如果在进行Mixed回收的时候，无论是年轻代还是老年代都基于复制算法进行回收，都要把各个Region的存活对象拷贝到别的Region里去

此时万一出现拷贝的过程中发现没有空闲Region可以承载自己的存活对象了，就会触发 一次失败。

一旦失败，立马就会切换为停止系统程序，然后采用单线程进行标记、清理和压缩整理，空闲出来一批Region，这个过程是极慢极慢的。

### 15、 各垃圾回收器的比较

比如说你的机器是32核64G的机器，此时你分配给系统的内存有几十个G，新生代的Eden区可能30G~40G的内存。

比如类似Kafka、Elasticsearch之类的大数据相关的系统，都是部署在大内存的机器上的，此时如果你的系统负载非常的高，对于大数据系统是很有
可能的，比如每秒几万的访问请求到Kafka、Elasticsearch上去。

那么可能导致你Eden区的几十G内存频繁塞满要触发垃圾回收，假设1分钟会塞满一次。

然后每次垃圾回收要停顿掉Kafka、Elasticsearch的运行，然后执行垃圾回收大概需要几秒钟，此时你发现，可能每过一分钟，你的系统就要卡顿几
秒钟，有的请求一旦卡死几秒钟就会超时报错，此时可能会导致你的系统频繁出错。

G1垃圾回收器，可以设置一个期望的每次GC的停顿时间，比如我们可以设置一个20ms。

那么G1基于他的Region内存划分原理，就可以在运行一段时间之后，比如就针对2G内存的Region进行垃圾回收，此时就仅仅停顿20ms，然后回收掉2G
的内存空间，腾出来了部分内存，接着还可以继续让系统运行。

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

### 16、 jstat摸清jvm

用jstat就可以非常轻松便捷的了解到线上系统的运行状况，从新对象增速、Young GC触发频率以及耗时，再到对象进入老年代的增速以及Full GC触
发频率以及耗时，可以完全摸清楚线上系统的JVM运行情况，为可能要做的优化做准备。

S0C：这是From Survivor区的大小

S1C：这是To Survivor区的大小

S0U：这是From Survivor区当前使用的内存大小

S1U：这是To Survivor区当前使用的内存大小

EC：这是Eden区的大小

EU：这是Eden区当前使用的内存大小

OC：这是老年代的大小

OU：这是老年代当前使用的内存大小

MC：这是方法区（永久代、元数据区）的大小

MU：这是方法区（永久代、元数据区）的当前使用的内存大小

YGC：这是系统运行迄今为止的Young GC次数

YGCT：这是Young GC的耗时

FGC：这是系统运行迄今为止的Full GC次数

FGCT：这是Full GC的耗时

GCT：这是所有GC的总耗时

jstat -gc PID 1000 10

除了上面的jstat -gc命令是最常用的以外，他还有一些命令可以看到更多详细的信息，如下所示：

jstat -gccapacity PID：堆内存分析

jstat -gcnew PID：年轻代GC分析，这里的TT和MTT可以看到对象在年轻代存活的年龄和存活的最大年龄

jstat -gcnewcapacity PID：年轻代内存分析

jstat -gcold PID：老年代GC分析

jstat -gcoldcapacity PID：老年代内存分析

jstat -gcmetacapacity PID：元数据区内存分析

其实有很多其他的工具也特别好用啊，比如JConsole、VisualVM等可视化的监控工具，还有其他一些开源的监控系统，都是可视化的。

### 17、 jmap和jhat摸清线上系统的对象分布

有的时候可能我们会发现JVM新增对象的速度很快，然后就想要去看看，到底什么对象占据了那么多的内存。

发现有的对象在代码中可以优化一下创建的时机，避免那种对象对内存占用过大，那么也许甚至可以去反过来优化一下代码。

jmap -heap PID：这个信息会打印出来堆内存相关的一些参数设置

jmap -histo PID：他会按照各种对象占用内存空间的大小降序排列，把占用内存最多的对象放在最上面。

jmap -dump:live,format=b,file=dump.hprof PID：生成一个堆内存快照放到一个文件里去。

jhat dump.hprof -port 7000：你就在浏览器上访问当前这台机器的7000端口号，就可以通过图形化的方式去分析堆内存里的对象分布情况了。

### 18、 cpu过高分析

大促活动一般都会吸引比平时多几倍的用户短时间内突然登录APP来参与，所以系统一般在这个时候压力会比平时大好几倍。

促活动开始之后，直接导致线上一个系统的CPU使用率飙升，而且因为CPU使用率太高，导致系统几乎陷入卡死的状态，无法处理任何请求！

机器CPU负载过高的两个常见的场景:

第一个场景，是你自己在系统里创建了大量的线程，这些线程同时并发运行，而且工作负载都很重，过多的线程同时并发运行就会导致你的机器CPU
负载过高。

第二个场景，就是你的机器上运行的JVM在执行频繁的Full GC，Full GC是非常耗费CPU资源的，他是一个非常重负载的过程所以一旦你的JVM有频繁
的Full GC，带来的一个明显的感觉，一个是系统可能时不时会卡死，因此Full GC会带来一定的“Stop the World”问题，一个是机器的CPU负载很高。

那么如果JVM GC频率很正常呢？那就肯定是你的系统创建了过多线程在并发执行负载很重的任务了！

一、频繁Full GC

1、内存分配不合理，导致对象频繁进入老年代，进而引发频繁的Full GC；

2、存在内存泄漏等问题，就是内存里驻留了大量的对象塞满了老年代，导致稍微有一些对象进入老年代就会引发Full GC；

3、永久代里的类太多，触发了Full GC

当时我们用jstat分析了一下线上系统的情况，发现并不存在内存分配不合理，对象频繁进入老年代的问题，而且永久代的内存使用也很正常，
所以上述三个原因中的两个就被排除掉了。

那么我们来考虑最后一个原因：老年代里是不是驻留了大量的对象给塞满了？

jmap+jhat的组合来分析内存里的大对象，因为jhat适合快速的去分析一下内存快照，但是功能上不是太强大，所以一般其实常用的比较强大的内存分
析工具，就是MAT。

### 19、 MAT

jmap -dump:format=b,file=文件名 【服务进程ID】,拿到了内存快照之后，其实就是一份文件，接着就可以用jhat、MAT之类的工具来分析内存了。

例如【jmap -dump:live,format=b,file=dump.hprof 27628】

不少人是通过Eclipse集成的MAT插件来使用的，但是很多人其实开发是用IntelliJ IDEA的，所以这个时候可以直接下载一个MAT来使用即可

给大家官网的下载地址：

https://www.eclipse.org/mat/downloads.php

在这个地址中，就可以下载MAT的最新版本了。

下载好MAT后，在他的安装目录里，可以看到一个文件名字叫做：MemoryAnalyzer.ini

这个文件里的内容类似如下所示：

-startup
../Eclipse/plugins/org.eclipse.equinox.launcher_1.5.0.v20180512-1130.jar
--launcher.library
../Eclipse/plugins/org.eclipse.equinox.launcher.cocoa.macosx.x86_64_1.1.700.v20180518-1200
-vmargs
-Xmx1024m
-Dorg.eclipse.swt.internal.carbon.smallFonts
-XstartOnFirstThread

大家务必要记得，如果dump出来的内存快照很大，比如有几个G，你务必在启动MAT之前，先在这个配置文件里给MAT本身设置一下堆内存大小，
比如设置为4个G，或者8个G，他这里默认-Xmx1024m是1G。

接着大家直接启动MAT即可，启动之后看到的界面中有一个选型是：Open a Heap Dump，就是打开一个内存快照的意思，选择他，然后选择本地的一个
内存快照文件即可。

使用MAT打开一个内存快照之后，在MAT上有一个工具栏，里面有一个按钮，他的英文是：Leak Suspects，就是内存泄漏的分析。

### 20、 OOM内存溢出

JVM的内存区域里大家都知道，有一块区域叫做永久代，当然JDK 1.8以后都叫做Metaspace了，我们也用最新的说法好了。

这块内存区域就是用来存放你系统里的各种类的信息的，包括JDK自身内置的一些类的信息，都在这块区域里。

![](./picture/37、jvm内存中永久代.png)

好，那么既然有这么一块Metaspace区域是用来存放类信息的，那是不是有可能在这个Metaspace区域里就会发生OOM？

没错，是有这种可能的。

Java虚拟机栈：让线程执行各种方法

大家都知道，我们写好的那些Java代码虽然是一个一个的类，但是其实核心的代码逻辑一般都是封装在类里面的各种方法中的

比如JVM已经加载了我们写好的HelloWorld类到内存里了，接着怎么执行他里面的代码呢？

Java语言中的一个通用的规则，就是一个JVM进程总是从main方法开始执行的，所以我们既然在HelloWorld中写了一个main()方法，那么当然得执行这个方法中的代码了。

但是等一等，JVM进程里的谁去执行main()方法的代码？

其实我们所有的方法执行，都必须依赖JVM进程中的某个线程去执行，你可以理解为线程才是执行我们写的代码的核心主体。

JVM进程启动之后默认就会有一个main线程，这个main线程就是专门负责执行main()方法的。

![](./picture/38、jvm执行线程.png)

java指令 -> main线程 -> 执行main方法 -> 到Metsspace区域找类

现在又有一个问题了，在main()方法里定义了一个局部变量，“message”，那么大家回忆一下，这些方法里的局部变量可能会有很多，那么这些局部变量是放在哪里的呢？

很简单，每个线程都有一个自己的虚拟机栈，就是所谓的栈内存。

然后这个线程只要执行一个方法，就会为方法创建一个栈桢，将栈桢放入自己的虚拟机栈里去，然后在这个栈桢里放入方法中定义的各种局部变量，如下图所示。

![](./picture/39、线程栈.png)

好，现在问题来了，大家如果还记得之前我们讲过的一个参数，应该都知道，我们是可以设置JVM中每个线程的虚拟机栈的内存大小的，一般是设置为1MB。

那么既然每个线程的虚拟机栈的内存大小是固定的，是否可能会发生虚拟机栈的内存溢出？

没错，所以第二块可能发生OOM的区域，就是每个线程的虚拟机栈内存。

最后我们知道，我们写好的代码里，特别在一些方法中，可能会频繁的创建各种各样的对象，这些对象都是放在堆内存里的，如下图所示。

而且我们通过之前的学习，也都知道了一点，通常我们在JVM中分配给堆内存的空间其实一般是固定的

既然如此，我们还不停在堆内存里创建对象，是不是说明，堆内存也有可能会发生内存溢出？

没错，第三块可能发生内存溢出的区域，就是堆内存空间！

![](./picture/40、jvm内存中的堆.png)

1、Metaspace区域满就会触发Full GC，Full GC会带着一块进行Old GC就是回收老年代的，也会带着回收年轻代的Young GC。

一旦你尝试回收了Metaspace中的类之后发现还是没能腾出来太多空间，此时还要继续往Metaspace中塞入更多的类，直接就会引发内存溢出的问题。
因为此时Metaspace区域的内存空间不够了。

一旦发生了内存溢出就说明JVM已经没办法继续运行下去了，此时可能你的系统就直接崩溃了，这就是Metaspace区域发生内存溢出的一个根本的原理。

2、JVM中的栈内存溢出

既然一个线程的虚拟机栈内存大小是有限的，比如1MB，那么假设你不停的让这个线程去调用各种方法，然后不停的把方法调用的栈桢压入栈中，
是不是就会不断的占用这个线程1MB的栈内存？

递归方法即可实现

3、堆内存溢出

平时系统运行的时候一直不停的创建对象，然后大量的对象会填满Eden区一旦Eden区满之后，就会触发一次Young GC，然后存活对象进入S区。

一旦出现了高并发场景，导致ygc后很多请求还没处理完毕，存活对象太多，可能就在Survivor区域放不下了，此时就只能进入到老年代里去了，老年
代很快就会放满了。

一旦老年代放满了就会触发Full GC

我们假设ygc过后有一批存活对象，Survivor放不了，此时就等着要进入老年代里，然后老年代也满了，那么就得等着老年代进行CMS GC，必须回收掉
一批对象，才能让年轻代里存活下来的一批对象进去。

这个时候如果年轻代还有一批对象等着放进老年代，人家GC过后空间还是不足怎么办？

还能怎么办！只能是内存溢出了！

系统承载高并发请求，因为请求量过大，导致大量对象都是存活的，所以要继续放入新的对象实在是不行了，此时就会引发OOM系统崩溃

系统有内存泄漏的问题，就是莫名其妙弄了很多的对象，结果对象都是存活的，没有及时取消对他们的引用，导致触发GC还是无法回收，此时只能引发
内存溢出，因为内存实在放不下更多对象了

### 21、 tomcat

我们是把写好的系统放入Tomcat目录中，然后启动Tomcat，此时我们启动的Tomcat本身就是一个JVM进程，因为Tomcat自己也是Java写的。

Tomcat自己就是一个JVM进程，我们写好的系统只不过是一些代码而已。

这些代码就是一个一个的类，这些类被Tomcat加载到内存里去，然后由Tomcat来执行我们写的类。

Tomcat有自己的工作线程，大家务必要对Tomcat的工作线程这个概念有一个认识，即Tomcat有很多自己的工作线程，少则一两百个，多则三四百个也是可以的。

然后从8080端口上收到的请求都会均匀的分配给这些工作线程去进行处理，而这些工作线程收到请求之后，就负责调用Spring MVC框架的代码，
Spring MVC框架又负责调用我们自己写好的代码，比如一些Controller类之类的

![](./picture/41、tomcat工作的样子.png)

jetty

与tomcate类似的容器

![](./picture/42、jetty.png)

### 99、 案例分析

### 一、 每日百万交易支付系统，如何设置内存？

a、每秒多少个订单？  30笔

假设每天100万个支付订单，那么一般用户交易行为都会发生在每天的高峰期，比如中午或者晚上。
假设每天高峰期大概是几个小时，用100万平均分配到几个小时里，那么大概是每秒100笔订单左右，咱们就以每秒100笔订单来计算一下好了。
假设我们的支付系统部署了3台机器，每台机器实际上每秒大概处理30笔订单。

b、处理一个支付订单要多久？1秒

咱们就假设一次支付请求的处理，包含一个支付订单的创建，大概需要1秒钟的时间。
那么大体上你的脑子里可以出现的一个流动的模型，应该是每台机器一秒钟接收到30笔支付订单的请求，然后在JVM的新生代里创建了30个支付订单的
对象，做了写入数据库等处理
接着1秒之后，这30个支付订单就处理完毕，然后对这些支付订单对象的引用就回收了，这些订单在JVM的新生代里就是没人引用的垃圾对象了。

c、每个支付订单需要多少内存？500byte

一般来说，比如支付订单这种核心类，你就按20个实例变量来计算，然后一般大概一个对象也就在几百字节的样子
我们算他大一点好了，就算一个支付订单对象占据500字节的内存空间，不到1kb。

d、每秒发起的支付占用多少内存？15kb

那么30个支付订单，大概占据的内存空间是30 * 500字节 = 15000字节，大概其实也就15kb而已。

but：

真实的支付系统线上运行，肯定每秒会创建大量其他的对象，但是我们结合这个访问压力以及核心对象的内存占据，大致可以来估算一下整个支付
系统每秒钟大致会占据多少内存空间。
其实如果你要估算的话，可以把之前的计算结果扩大10倍~20倍。也就是说，每秒钟除了在内存里创建支付订单对象，还会创建其他数十种对象。
那么每秒钟创建出来的被栈内存的局部变量引用的对象大致占据的内存空间就在几百KB到1MB之间。
然后下一秒继续来新的请求创建大概1MB的对象放在新生代里，接着变成垃圾，再来下一秒。
循环多次之后，新生代里垃圾太多，就会触发Minor GC回收掉这些垃圾。这就是一个完整系统的大致JVM层面的内存使用模型。

so：

机器采用4核8G，然后-Xms和-Xmx设置为3G，给整个堆内存3G内存空间，-Xmn设置为2G，给新生代2G内存空间。

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

### 二、 一个日处理上亿数据的计算系统
  
这个数据计算系统会不停的通过SQL语句和其他方式从各种数据存储中提取数据到内存中来进行计算，大致当时的生产负载是每分钟大概需要执行500次
数据提取和计算的任务。

每台机器是4核8G的配置，JVM内存给了4G，其中新生代和老年代分别是1.5G。新生代是按照8:1:1的比例来分配Eden和两块Survivor的区域，那么大
体上来说，Eden区就是1.2GB，每块Survivor区域在100MB左右。

这是一套分布式运行的系统，所以生产环境部署了多台机器，每台机器大概每分钟负责执行100次数据提取和计算的任务。

每次会提取大概1万条左右的数据到内存里来计算，平均每次计算大概需要耗费10秒左右的时间。

数据都是比较大的，大概每条数据包含了平均20个字段，可以认为平均每条数据在1KB左右的大小。

那么每次计算任务：10000*1KB=10MB。每秒计算任务：每分钟100次约等于120次，120/60=2次计算任务。每秒数据量为10MB×2=20MB。

基本上一分钟过后，Eden区里就全是对象，基本就全满了。

![](./picture/19、案例2-1.png)

每秒20mb的内存写入，在minorGC回收垃圾时，前10秒内的内存不是垃圾，大概200mb左右的存活对象不能回收。

![](./picture/20、案例2-2.png)

此时一次Minor GC就会回收掉1GB的对象，然后200MB的对象能放入Survivor区吗?不能！因为任何一块Survivor区实际上就100MB的空间，此时就会
通过空间担保机制，让这200MB对象直接进入老年代去，占用里面200MB内存空间，然后Eden区就清空了
                                                
![](./picture/21、案例2-3.png)

大概在运行了7分钟过后，7次Minor GC执行过后，大概1.4G对象进入老年代，老年代剩余空间就不到100MB了，几乎快满了。

如何优化：

最大的问题，其实就是每次Survivor区域放不下存活对象。所以当时我们就是对生产系统进行了调整，增加了新生代的内存比例，3GB左右的堆内存，
其中2GB分配给新生代，1GB留给老年代，这样Survivor区大概就是200MB，每次刚好能放得下Minor GC过后存活的对象了。

![](./picture/22、案例2-4.png)

通过这个分析和优化，定时我们成功的把生产系统的老年代Full GC的频率从几分钟一次降低到了几个小时一次，大幅度提升了系统的性能，避免了频繁
Full GC对系统运行的影响。

案例分析拓展：

如果工作负载扩大10倍，那么大家参照上图来看，此时会导致每秒钟要加载100MB的数据到内存里去，对于1.6G的Eden而言，10多秒就会迅速塞满，
此时就会触发Young GC。

此时就会导致每隔10多秒，就有1GB的数据进入老年代中，而老年代之前给大家说过，也就1GB左右的空间而已，即使勉强让你放下了，那么下一次过10
多秒之后，又会放1GB的对象到老年代，此时必然会提前触发Full GC去回收老年代里的1GB的对象，然后再让你把这次Young GC后存活的1GB对象放入
老年代。

这就是当时我们遇到的真实生产场景，基本上一台4核8G的机器，每分钟要触发二三次Full GC，对系统性能造成了巨大的影响，简直是可怕至极。

所以更换成了每台机器都是16核32G的高配置机器。这样的话，Eden基本上空间会扩大10倍，比如有16GB。

Survivor区域分配的是每个Survivor有2GB内存，所以每次Young GC过后的存活对象可以轻松放入Survivor区域中，不会进入老年代。这就完美的通
过提升机器配置的方式，解决了频繁Young GC和Full GC的问题。

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

### 三、 每日上亿请求量的电商系统

一般按每个用户平均访问20次来计算，那么上亿请求量，大致需要有500万日活用户。

这里可以按照10%的付费转化率来计算，每天大概有50万人会下订单，那么大致就是每天会有50万订单。

这50万订单算他集中在每天4小时的高峰期内，那么其实平均下来每秒钟大概也就几十个订单。

假设在类似双11的节日里，零点的时候，很多人等着大促开始就要剁手购物，这个时候，可能在大促开始的短短10分钟内，瞬间就会有50万订单。每秒
就会有接近1000的下单请求。

按3台来算，就是每台机器每秒需要抗300个下单请求。

每个订单咱们就按1kb的大小来估算，单单是300个订单就会有300kb的内存开销，然后算上订单对象连带的订单条目对象、库存、促销、优惠券等等一
系列的其他业务对象，一般需要对单个对象开销放大10倍~20倍，此外，除了下单之外，这个订单系统还会有很多订单相关的其他操作，比如订单查询之
类的，所以连带算起来，可以往大了估算，再扩大10倍的量。那么就是300×20×10=60mb。

我们有4核8G的机器，那么给JVM的内存一般会到4G，剩下几个G会留点空余给操作系统之类的来使用，不要想着把机器内存一下子都耗尽，其中堆内存
我们可以给3G，新生代我们可以给到1.5G，老年代也是1.5G。然后每个线程的Java虚拟机栈有1M，那么JVM里如果有几百个线程大概会有几百M,然后再
给永久代256M内存，基本上这4G内存就差不多了。

“-Xms3072M -Xmx3072M -Xmn1536M -Xss1M -XX:PermSize=256M -XX:MaxPermSize=256M”

![](./picture/25、案例3-1、.png)

首先每次新生代垃圾回收在100MB左右，有可能会突破150MB，那么岂不是经常会出现Minor GC过后的对象无法放入Survivor中？然后岂不是频繁会让
对象进入老年代？

“-Xms3072M -Xmx3072M -Xmn2048M -Xss1M -XX:PermSize=256M -XX:MaxPermSize=256M  -XX:SurvivorRatio=8”

![](./picture/26、案例3-2.png)

“-Xms3072M -Xmx3072M -Xmn2048M -Xss1M  -XX:PermSize=256M -XX:MaxPermSize=256M  -XX:SurvivorRatio=8 
-XX:MaxTenuringThreshold=5”

也就是说一个对象如果躲过5次Minor GC，在新生代里停留超过1分钟了，尽快就让他进入老年代，别在新生代里占着内存了。

“-Xms3072M -Xmx3072M -Xmn2048M -Xss1M  -XX:PermSize=256M -XX:MaxPermSize=256M  -XX:SurvivorRatio=8 
-XX:MaxTenuringThreshold=5 -XX:PretenureSizeThreshold=1M”

大对象可以直接进入老年代 ,一般很少有超过1MB的大对象。如果有，可能是你提前分配了一个大数组、大List之类的东西用来放缓存的数据。

“-Xms3072M -Xmx3072M -Xmn2048M -Xss1M  -XX:PermSize=256M -XX:MaxPermSize=256M  -XX:SurvivorRatio=8 
-XX:MaxTenuringThreshold=5 -XX:PretenureSizeThreshold=1M -XX:+UseParNewGC -XX:+UseConcMarkSweepGC”

ParNew垃圾回收器的核心参数，其实就是配套的新生代内存大小、Eden和Survivor的比例，只要你设置合理，避免Minor GC后对象放不下Survivor
进入老年代，或者是动态年龄判定之后进入老年代，给新生代里的Survivor充足的空间，那么Minor GC一般就没什么问题。

其实对任何系统，首先类似上文的内存使用模型预估以及合理的分配内存，尽量让每次Minor GC后的对象都留在Survivor里，不要进入老年代，这是
你首先要进行优化的一个地方。

![](./picture/27、案例3-3.png)

老年代可用内存最多也就1G，新生代对象总大小最多可以有1.8G。

1、那么会导致每次Minor GC前一检查，都发现“老年代可用内存” < “新生代总对象大小”，这会导致每次Minor GC前都触发Full GC。

2、检查一下“老年代可用内存空间” < “历次Minor GC后升入老年代的平均对象大小”，这也会导致每次Minor GC前都触发Full GC。

3、Minor GC后要升入老年代的对象有几百MB，但是老年代可用空间不足了，这也会导致每次Minor GC前都触发Full GC。

4、“-XX:CMSInitiatingOccupancyFaction”参数，比如设定值为92%，那么此时可能前面几个条件都没满足，但是刚好发现这个条件满足了，
比如就是老年代空间使用超过92%了，此时就会自行触发Full GC。

所以很可能是在系统运行半小时~1小时之后，才会有接近 1GB的对象进入老年代。

假设就是订单系统运行1小时之后，老年代大概有900MB的对象了，剩余可用空间仅仅只有100MB了，此时就会触发一次Full GC。

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

### 四、 百万级用户的在线教育平台，如何基于G1垃圾回收器优化性能

每天晚上那两三小时的高峰时期，几乎你可以认为每天几十万日活用户（那些小孩儿）都会集中在这个时间段来平台上上在线课程，比如青少年英语课，
或者数学课之类的。

所以这个晚上两三小时的时间段里，将会是平台每天绝对的高峰期，而且白天几乎没什么流量，可能99%的流量都集中在晚上。

晚上3小时高峰期内有总共60万活跃用户，平均每个用户大概会使用1小时左右来上课，那么每小时大概会有20万活跃用户同时在线学习。

这20万活跃用户因为需要进行大量的互动操作，所以大致可以认为是每分钟进行1次互动操作，一小时内会进行60次互动操作

那么20万用户在1小时内会进行1200万次互动操作，平均到每秒钟大概是3000次左右的互动操作，这是一个很合理的数字。

每秒钟要承载3000并发请求，根据经验来看，一般系统的核心服务需要部署5台4核8G的机器来抗住是差不多的，每台机器每秒钟抗个600请求。

每秒会有600个请求会占用3MB左右的内存空间。

那么假设我们对机器上的JVM，分配4G给堆内存，其中新生代默认初始占比为5%，最大占比为60%，每个Java线程的栈内存为1MB，
元数据区域（永久代）的内存为256M。

“-Xms4096M -Xmx4096M  -Xss1M  -XX:PermSize=256M -XX:MaxPermSize=256M -XX:+UseG1GC“

此时堆内存共4G，那么此时会除以2048，计算出每个Region的大小，此时每个Region的大小就是2MB，刚开始新生代就占5%的Region，可以认为新生
代就是只有100个Region，有200MB的内存空间。

首先，随着系统运行，每秒创建3MB的对象，大概1分钟左右就会塞满100个Region（200MB内存），如果现在触发gc，可能只用到十几ms，与设置的
200ms相差甚远，为了减少频繁gc出现，先等待。

然后系统继续运行，一直到可能300个Region都占满了，此时通过计算发现回收这300个Region大概需要200ms，那么可能这个时候就会触发一次新生代
gc了。

G1它本身是这样的一个运行原理，他会根据你预设的gc停顿时间，给新生代分配一些Region，然后到一定程度就触发gc，并且把gc时间控制在预设范围
内，尽量避免一次性回收过多的Region导致gc停顿时间超出预期。

对于G1而言，我们首先应该给整个JVM的堆区域足够的内存，比如我们在这里就给了JVM超过5G的内存，其中堆内存有4G的内存。

接着就应该合理设置“-XX:MaxGCPauseMills”参数，默认值是200毫秒。

如果这个参数设置的小了？
那么说明每次gc停顿时间可能特别短，此时G1一旦发现你对几十个Region占满了就立即触发新生代gc，然后gc频率特别频繁，虽然每次gc时间很短。

如果这个参数设置大了呢？

那么可能G1会允许你不停的在新生代理分配新的对象，然后积累了很多对象了，再一次性回收几百个Region，此时可能一次GC停顿时间就会达到几百
毫秒，但是GC的频率很低。比如说30分钟才触发一次新生代GC，但是每次停顿500毫秒。

所以这个参数到底如何设置，需要结合后续给大家讲解的系统压测工具、gc日志、内存分析工具结合起来进行考虑，尽量让系统的gc频率别太高，同时
每次gc停顿时间也别太长，达到一个理想的合理值。

mixed gc如何优化？

对于这个mixed gc的触发，大家都知道是老年代在堆内存里占比超过45%就会触发。

mixed gc本身很复杂，很多参数可以优化，但是优化mixed gc的核心不是优化他的参数，而是跟我们之前分析的思路一样，尽量避免对象过快进入老
年代，尽量避免频繁触发mixed gc，就可以做到根本上优化mixed gc了。

假设你“-XX:MaxGCPauseMills”参数设置的值很大，导致系统运行很久，新生代可能都占用了堆内存的60%了，此时才触发新生代gc。

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

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

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

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

### 五、 每秒10万并发的BI系统是如何频繁发生YoungGC的？

首先从我们提供给商家日常使用的一个平台上会采集出来很多商家日常经营的数据。

接着就可以对这些经营数据依托各种大数据计算平台，比如Hadoop、Spark、Flink等技术进行海量数据的计算，计算出来各种各样的数据报表。

然后我们需要将计算好的各种数据分析报表都放入一些存储中，比如说MySQL、Elastcisearch、HBase都可以存放类似的数据。

最后一步，就是基于MySQL、HBase、Elasticsearch中存储的数据报表，基于Java开发出来一个BI系统，通过这个系统把各种存储好的数据暴露给前
端，允许前端基于各种条件对存储好的数据进行复杂的筛选和分析。

刚开始的时候，这个BI系统使用的商家是不多的。因为大家要知道，即使在一个庞大的互联网大厂里，虽然说大厂本身积累了大量的商家，但是你要是
针对他们上线一个付费的产品，刚开始未必所有人都买账，所以一开始系统上线大概就少数商家在使用，比如就几千个商家。

所以刚开始系统部署的非常简单，就是用几台机器来部署了上述的BI系统，机器都是普通的4核8G的配置，然后在这个配置之下，一般来说给堆内存中的
新生代分配的内存都在1.5G左右，Eden区大概也就1G左右的空间。

![](./picture/31、案例4-1.png)

突然使用系统的商家开始越来越多，比如给大家举个例子，当商家的数量级达到几万的时候。

基本上会出现你BI系统部署的每台机器每秒的请求会达到几百个，我们假设就是每秒500个请求吧。

每个请求大概需要加载出来100kb的数据进行计算，因此每秒500个请求，就需要加载出来50MB的数据到内存中进行计算，如下图所示。

![](./picture/32、案例4-2.png)

基本上每秒会加载50MB的数据到Eden区中，只要区区200s，也就是3分钟左右的时间，就会迅速填满Eden区，然后触发一次Young GC对新生代进行垃
圾回收。

当然1G左右的Eden进行Young GC其实速度相对是比较快的，可能也就几十ms的时间就可以搞定了。

针对这样的一套系统，后来随着越来越多的商家来使用，并发压力越来越大，甚至高峰期会有每秒10万的并发压力。

如果还是用4核8G的机器来支撑，那么可能需要部署上百台机器来抗住每秒10万的高并发压力。

所以一般针对这种情况，我们会提升机器的配置，本身BI系统就是非常吃内存的系统，所以我们将部署的机器全面提升到了16核32G的高配置机器上去。

但是此时问题就来了，大家可以想一下，如果要是用大内存机器的话，那么新生代至少会分配到20G的大内存，Eden区也会占据16G以上的内存空间，
此时如下图所示。

![](./picture/27、案例3-3.png)

此时每秒几千请求的话，每秒大概会加载到内存中几百MB的数据，那么大概可能几十秒，甚至1分钟左右就会填满Eden区，会就需要执行Young GC。
此时Young GC要回收那么大的内存，速度会慢很多，也许此时就会导致系统卡顿个几百毫秒，或者1秒钟。

所以当时对这个系统的一个优化，就是采用G1垃圾回收器来应对大内存的Young GC过慢的问题。

对G1设置一个预期的GC停顿时间，比如100ms，让G1保证每次Young GC的时候最多停顿100ms，避免影响终端用户的使用。

只有在你机器内存特别大的时候，要注意Young GC也可能会导致比较长时间的停顿，此时针对大内存机器通常建议采用G1垃圾回收器。

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

### 六、 每秒十万QPS的社交APP,如何优化GC性能提升3倍？

一个有高峰期每秒十万QPS的社交APP。

一般这类APP都会通过各种方式来给你推荐一些周边的陌生人，然后你可能会看到一些感兴趣的人，就会进入他/她的个人主页去看一看。个人主页里可
能就包含了那个人的一些自我介绍，照片之类的东西。

所以这类APP，在晚上高峰期，流量最大的一个模块，其实就是个人主页模块。

会有大量的活跃用户在一个集中的时间段内频繁的访问各种个人主页数据，而且这类数据的量还通常很大，要包含很多的信息，通常一个个人主页的数
据甚至可能有几MB。

而且一般在高峰期内，有可能一些活跃用户他可能会连续不断的去点击他感兴趣的人的个人主页，比如连续1个小时都在不停的点击。

所以其实这类社交APP他的高峰期QPS时很高的。在当时的场景中，这个社交APP流量最大的个人主页模块高峰期最多每秒会有10万+的QPS。

因为这个社交APP的日活用户涨的很快，所以导致他的高峰期QPS很快就飙升到了10万。

正是因为每秒并发量太高，这也直接导致了这个系统在高峰期的时候，年轻代的Eden区会迅速的被填满，并且频繁的触发Young GC。

每次在Young GC的时候，实际上还有很多请求是没处理完毕的，没办法，因为每秒请求量太多了，所以在你触发Young GC的时候，就这一瞬间，
必然有很多请求是还没处理完毕的。

这就导致Eden区中其实每次触发Young GC的时候，都有很多对象是需要存活下来的。

因此在高峰期的时候，其实经常会出现Young GC过后存活对象较多，在Survivor区中放不下的问题。

所以此时必然会导致大量的对象快速的进入老年代中，所以在上述社交APP高峰期高并发场景下，必然会导致个人主页服务对应的JVM频繁的发生老年代
的GC。

![](./picture/33、案例6-1.png)

其实大家都知道，针对上述场景，最核心的优化点，主要应该是增加机器，尽量让每台机器承载更少的并发请求，减轻压力。

同时，给年轻代的Survivor区域更大的内存空间，让每次Young GC后的存活对象务必停留在Survior中，别进入老年代。

-XX:+UseCMSCompactAtFullCollection -XX:CMSFullGCsBeforeCompaction=5

CMS垃圾回收器默认是采用标记-清理算法，所以是会造成大量的内存碎片的。

![](./picture/34、案例6-2.png)

然后CMS垃圾回收器一次垃圾回收过后，回收掉了一些垃圾对象，此时可能内存里看起来跟下面这样：

![](./picture/35、案例6-3.png)

大家注意上面那个红圈的地方，因为回收掉了一个对象，所以那里出现了一个内存碎片

虽然这里是空白内存，但是假如此时你要是要分配一个对象比较大，没法再上面红圈处放进去呢？那么红圈的那个内存碎片不就没任何意义了？

所以CMS正常垃圾回收，因为使用标记-清理算法，所以必然导致大量的内存碎片。

所以“-XX:+UseCMSCompactAtFullCollection -XX:CMSFullGCsBeforeCompaction=5”两个参数的含义，
就是在5次Full GC之后会触发一次Compaction操作，也就是压缩操作

![](./picture/36、案例6-4.png)

所以当时第二个参数的优化就是针对CMS内存碎片问题的

在降低了Full GC频率之后，务必设置如下参数“-XX:+UseCMSCompactAtFullCollection -XX:CMSFullGCsBeforeCompaction=0”，
每次Full GC后都整理一下内存碎片。

否则如果每次Full GC过后，都造成老年代里很多内存碎片，那么必然导致下一次Full GC更快到来，因为内存碎片会导致老年代可用内存变少。

起床，何爵为/jvm

简介

发行版

贡献者

近期动态

起床，何爵为/jvm .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

起床，何爵为/jvm