课程内容：
1、Jmap，Jstack，Jinfo命令详解
2、Jvisualvm调优工具实战
3、JVM内存或CPU飙高如何快速定位
4、Jstat命令预估JⅣVM运行情况
5、系统频繁Full GC导致系统卡顿实战调优
6、内存泄露到底是怎么回事
事先启动一个web应用程序，用jps查看其进程id，接着用各种jdk自带命令优化应用。
因此为了后续使用，我们直接从创建一个web项目开始，该部分知识是为了复习之前所学内容。
创建一个springboot项目
①. 首先打开idea，找到new module
②. 点击next，填入下列信息
在这里插入图片描述
③. 点击下一步继续选择
④. 继续下一步，检查信息
⑤. 完成（如果包加载的特别慢，记得配置一下maven）
写一个简单的小例子
①写一段代码
package com.ding.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/books")
public class BookController {
@GetMapping
public String getById(){
System.out.println("springboot is running.......");
return "springboot is running........";
}
}
② 运行启动类
③ 访问成功
注意事项：记得把启动类与文件放的目录关系
将该项目打包成jar项目
我们现在启动该jar包。
找到文件的位置
java -jar jvm03-0.0.1-SNAPSHOT.jar
然后这个界面就可以访问了
用jps查看其进程id
此命令可以用来查看内存信息，示例个数以及占用内存大小。
jmap -histo 21480（进程号）
其实一般这样就可以了，但是这样不好看，所以我们可以把他写到一个文件里面。
jmap -histo 21480 > ./log.txt
这样就打印到D盘去了
jmap -heap 21480
jmap -dump:format=b,file=eureka.hprof 21480
导出的信息：
这个信息的作用是等一会可以导到可视化工具里面的。例如jvisualvm。
进入之后是这个界面
在这个里面它可以装入文件，就是刚才我们所生成的文件。
我们就可以看到我们当时保存快照时候的堆信息情况
也可以设置内存溢出自动导出dump文件(内存很大的时候，可能会导不出来)
示例代码:（这个代码是我又写的，不是那个jar里面的）
package ding;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
public class OOMTest {
public static List<Object> list = new ArrayList<>();
public static void main(String[] args) {
//ArrayList<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());
}
}
}
这个程序我们知道肯定会溢出，但是我们假如这两个参数，在快溢出的时候会导出一个快照文件。
现在来验证一下，首先配置一下，把内存设置的小一点，方便他溢出
-Xms10M -Xmx10M -XX:+PrintGCDetails -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=D:\jvm.dump
运行之前D盘是没有那个jvm.dump文件的，运行之后就会产生。
现在我们把这个文件导入到那个jvisualvm工具中。
导入之后就可以看到什么类比较多，看主要是谁占的内存比较多
使用jstack加进程id查找死锁，见如下示例
package ding;
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){
System.out.println("thread1 begin");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock2){
System.out.println("thread1 end");
}
}
}).start();
new Thread(()->{
synchronized (lock2){
System.out.println("thread2 begin");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock1){
System.out.println("thread2 end");
}
}
}).start();
System.out.println("main thread end");
}
}
在运行的时候能看到程序一直在运行，但是不动，发生了死锁。
这个时候就可以使用jstack命令去看到底是怎么回事。
查询一下进程号
这个时候就可以看到详细信息
“Thread-1” 线程名
prio=5 优先级=5
tid=Ox000000001fa9e000 线程id
nid=Ox2d64 线程对应的本地线程标识
nidjava.lang.Thread.State: BLOCKED 线程状态
并且在这个详细信息里面会提示发现死锁
也可以使用jvisualvm也可以直接检测到死锁。我们打开这个工具他会自动识别这个进程。
立马能显示检测到死锁（我这个中间我把这个进程杀死了，重新启动的，进程id变化了一下哈，但是不影响实验）
点击上图右上角的线程dump可以看到详细的信息。就是和我们的那个刚才黑窗口里面的信息是一样的。
启动普通的jar程序JMX端口配置：
java ‐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 ‐jar microservice‐eureka‐server.jar
PS：
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 #临时关闭防火墙
package ding;
public class Math {
public static final int initData = 666;
public static People people = new People();
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();
}
}
}
使用命令top -p<pid>,显示你的java进程的内存情况，pid时你的java进程号，比如21919
按H，获取每个线程的内存情况
3. 找到内存和cpu占用最高的线程id，比如21919
4. 转为十六进制得到0x55A0，此为线程id的十六进制表示（因为那个工具展示出来的就是十六进制的，因此为了相对应我们在此也转化成16进制表示）
5. 执行jstack 21919|grep -A 10 55a0，得到线程堆栈信息中这个线程所在行的后面10行，从堆栈中可以发现导致cpu飙高的调用方法。
6. 查看对应堆栈信息找出可能存在问题的代码
查看正在运行的java应用程序的扩展参数
查看jvm的参数
jinfo -flags 进程号
查看java系统参数
jinfo -sysprops 进程号
jstat命令可以查看堆内存各部分的使用量，以及加载类的数量。命令的格式如下
jstat [-命令选项][vmid] [间隔时间(毫秒)][查询次数]
注意:使用的jdk版本是jdk8
jstat -gc pid最常用，可以评估程序内存使用及GC压力整体情况。
S0C:第一个幸存区的大小，单位KB
S1C:第二个幸存区的大小
S0U:第一个幸存区的使用大小
S1U:第二个幸存区的使用大小
EC:伊甸园区的大小
EU:伊甸园区的使用大小
OC:老年代大小
OU:老年代使用大小
MC:方法区大小(元空间)
MU:方法区使用大小
CCSC:压缩类空间大小
CCSU:压缩类空间使用大小
YGC:年轻代垃圾回收次数
YGCT:年轻代垃圾回收消耗时间，单位s
FGC:老年代垃圾回收次数
FGCT:老年代垃圾回收消耗时间，单位s
GCT:垃圾回收消耗总时间，单位s
NGCMN:新生代最小容量
NGCMX:新生代最大容量
NGC:当前新生代容量
S0C:第一个幸存区大小
S1C:第二个幸存区的大小
EC:伊甸园区的大小
OGCMN:老年代最小容量
OGCMX:老年代最大容量
OGC:当前老年代大小
OC:当前老年代大小
MCMN:最小元数据容量
MCMX:最大元数据容量
MC:当前元数据空间大小
CCSMN:最小压缩类空间大小
CCSMX:最大压缩类空间大小
CCSC:当前压缩类空间大小
YGC:年轻代gc次数
FGC:老年代GC次数
jstat -gcnew 20636
SOC:第一个幸存区的大小
S1C:第二个幸存区的大小
SOU:第一个幸存区的使用大小
S1U:第二个幸存区的使用大小
TT:对象在新生代存活的次数
MTT:对象在新生代存活的最大次数
DSS:期望的幸存区大小
EC:伊甸园区的大小
EU:伊甸园区的使用大小
YGC:年轻代垃圾回收次数
YGCT:年轻代垃圾回收消耗时间
jstat -gcnewcapacity 20636
NGCMN:新生代最小容量
NGCMX:新生代最大容量
NGC:当前新生代容量
S0CMX:最大幸存1区大小
S0C:当前幸存1区大小
S1CMX:最大幸存2区大小
S1C:当前幸存2区大小
ECMX:最大伊甸园区大小
EC:当前伊甸园区大小
YGC:年轻代垃圾回收次数
FGC:老年代回收次数
jstat -gcold 20636
MC:方法区大小
MU:方法区使用大小
CCSC:压缩类空间大小
CCSU:压缩类空间使用大小
OC:老年代大小
OU:老年代使用大小
YGC:年轻代垃圾回收次数
FGC:老年代垃圾回收次数
FGCT:老年代垃圾回收消耗时间
GCT:垃圾回收消耗总时间
jstat -gcoldcapacity 20636
OGCMN:老年代最小容量
OGCMX:老年代最大容量
OGC:当前老年代大小
OC:老年代大小
YGC:年轻代垃圾回收次数
FGC:老年代垃圾回收次数
FGCT:老年代垃圾回收消耗时间
GCT:垃圾回收消耗总时间
jstat -gcmetacapacity 20636
MCMN:最小元数据容量
MCMX:最大元数据容量
MC:当前元数据空间大小
CCSMN:最小压缩类空间大小
CCSMX:最大压缩类空间大小
CCSC:当前压缩类空间大小
YGC:年轻代垃圾回收次数
FGC:老年代垃圾回收次数
FGCT:老年代垃圾回收消耗时间
GCT:垃圾回收消耗总时间
jstat -gcutil 20636
S0:幸存1区当前使用比例
S1:幸存2区当前使用比例
E:伊甸园区使用比例
O:老年代使用比例
M:元数据区使用比例
CCS:压缩使用比例
YGC:年轻代垃圾回收次数
FGC:老年代垃圾回收次数
FGCT:老年代垃圾回收消耗时间
GCT:垃圾回收消耗总时间
用jstat gc-pid 命令可以计算出如下一些关键数据，有了这些数据就可以采用之前介绍过的优化思路，先给自己的系统设置一些初始性的JVM参数，比如堆内存大小，年轻代大小，Eden和Survivor的比例，老年代的大小，大对象的阈值，大龄对象进入老年代的阈值等。
年轻代对象增长的速率
可以执行命令jstat -gc pid 100 10(每隔1秒执行1次命令，共执行10次)，通过观察EU(eden区的使用)来估算每秒eden大概新增多少对象，如果系统负载不高可以把频率1秒换成1分钟，甚至10分钟来观察整体情况。注意，一般系统可能有高峰期和日常期，所以需要在不同的时间分别估算不同情况下对象增长速率。
Youpg GC的触发频率和每次耗时
知道年轻代对象增长速率我们就能推根据eden区的大小推算出Young GC大概多久触发一次，Young GC的平均耗时可以通过YGCTYGC公式算出，根据结果我们大概就能知道系统大概多久会因为Young GC的执行而卡顿多久。
每次Young GC后有多少对象存活和进入老年代
这个因为之前已经大概知道Young GC的频率，假设是每5分钟一次，那么可以执行命令jstat-gc pid 30000 10，观察每次结果eden， survivor和老年代使用的变化情况，在每次gc后eden区使用一般会大幅减少，sunivor和老年代都有可能增长，这些增长的对象就是每次Young GC后存活的对象，同时还可以看出每次Young GC后进去老年代大概多少对象，从而可以推算出老年代对象增长速率。
Full GC的触发频率和每次耗时
知道了老年代对象的增长速率就可以推算出Ful GC的触发频率了，Full GC的每次耗时可以用公式FGCT/FGC计算得出。
优化思路： 其实简单来说就是尽量让每次Young GC后的存活对象小于Survivor区域的50%，都留存在年轻代里。尽量别让对象进入老年代。尽量减少Full GC的频率，避免频繁Full GC对JVM性能的影响。
机器配置: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
整个堆是1.5G，年轻代是512M，得出老年代1G。
并且从配置可以看出是6：1：1，因此得到eden区是384M，S0是64M，S1是64M
我们得到信息是每分钟会发生1次Young GC，也就是1分钟这个eden区肯定能放满。那一分钟60秒，大概1秒钟产生多少对象，大概6M左右是吧，60×6=360，也就是6M多一点点。
Full GC平均每小时3次，也就是每20分钟一次Ful GC，而老年代差不多是1G，那意思就是20分钟带盖有700M对象挪到老年代，使其产生Full GC（最所以说产生700M就Full GC，是因为-XX:CMSInitiatingOccupancyFraction=75这个参数是指75%，占老年代75%就触发Full GC）
大家可以结合对象挪动到老年代那些规则推理下我们这个程序可能存在的一些问题
总共四种情况：大对象、长期存活的对象进入老年代、对象动态年龄判断、老年代空间分配担保机制（这种一般都是发生在老年代比较小的情况）。
经过分析感觉可能会由于对象动态年龄判断机制导致full gc较为频繁
为了给大家看效果，模拟一个示例程序(见课程对应工程代码: jvm-full-gc)打印了jstat的结果如下:
jstat -gc pid 2000 10000
线上面本来是没有问题的，后来就慢慢有问题了。
对于对象动态年龄判断机制导致的full gc较为频繁可以先试着优化下JVM参数，把年轻代适当调大点:
-Xms1536M -Xmx1536M -xmn1024 -Xss256K -XX:SurvivorRatio=6 -XX:MetaspaceSize=256M -XX:MaxMetaspaceSize=256M
-XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=92 -XX +UseCMSInitiatingOccupancyOnly
优化玩发现没有什么变化，full gc的次数比minor gc的次数还多了
我们可以推测下full gc比minor gc还多的原因有哪些?
1、元空间不够导致的多余full gc（在上述信息中元空间的值几乎没有什么变化）
2、显示调用System.gc()造成多余的full gc，这种一般线上尽量通过-XX:+DisableExplicitGC参数禁用，如果加上了这个JVM启动参数，那么代码中调用System.gc()没有任何效果
3、老年代空间分配担保机制
什么情况下是full gc的次数比minor gc的次数还多了，是老年代空间担保机制。
就是平均做一次minor gc做两次full gc
最快速度分析完这些我们推测的原因以及优化后，我们发现young gc和full gc依然很频繁了，而且看到有大量的对象频繁的被挪动到老年代，这种情况我们可以借助jmap命令大概看下是什么对象
查到了有大量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<User> users = queryUsers();
for (User user: users) {
//TODO 业务处理
System.out.println("user:" + user.toString());
}
return "end";
}
/**
* 模拟批量查询用户场景
* @return
*/
private ArrayList<User> queryUsers() {
ArrayList<User> users = new ArrayList<>();
for (int i = 0; i < 5000; i++) {
users.add(new User(i,"zhuge"));
}
return users;
}
}
同时，java的代码也是需要优化的，一次查询出500M的对象出来，明显不合适，要根据之前说的各种原则尽量优化到合适的值，尽量消除这种朝生夕死的对象导致的full gc
我们还可以使用jvisualvm来查看内存信息。
入股这个User信息比较多，不好定位的话那就应该进行如下操作进行定位。
再给大家讲一种情况，一般电商架构可能会使用多级缓存架构，就是redis加上JVM级缓存，大多数同学可能为了图方便对于JVM级缓存就简单使用一个hashmap，于是不断往里面放缓存数据，但是很少考虑这个map的容量问题，结果这个缓存map越来越大，一直占用着老年代的很多空间，时间长了就会导致full gc非常频繁，这就是一种内存泄漏，对于一些老旧数据没有及时清理导致一直占用着宝贵的内存资源，时间长了除了导致full gc，还有可能导致OOM。
这种情况完全可以考虑采用一些成熟的JVM级缓存框架来解决，比如ehcache等自带一些LRU数据淘汰算法的框架来作为JVM级的缓存。