JVM调优工具详解及调优实战

前置启动程序

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

Jmap

此命令可以用来查看内存信息，实例个数以及占用内存大小

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

打开 log.txt，文件内容如下：

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[][]

堆内存 dump

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

也可以设置内存溢出自动导出 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());

 }

 }

 }

Jstack

用 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) {

 }

<a name="br4"></a> synchronized (lock1) {

 System.out.println("thread2 end");

 }

 }

 }).start();


 System.out.println("main thread end");

 }

 }

"Thread-1" 线程名
prio=5 优先级=5
tid=0x000000001fa9e000 线程 id
nid=0x2d64 线程对应的本地线程标识 nid
java.lang.Thread.State: BLOCKED 线程状态

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();

 }
}
 }

使用命令 top -p ，显示你的 Java 进程的内存情况，pid 是你的 Java 进程号，比如 19663
按 H，获取每个线程的内存情况
找到内存和 CPU 占用最高的线程 tid，比如 19664
转为十六进制得到 0x4cd0，此为线程 id 的十六进制表示
执行 jstack 19663|grep -A 10 4cd0，得到线程堆栈信息中 4cd0 这个线程所在行的后面 10 行，从堆栈中可以发现导致 CPU 飙高的调用方法
查看对应的堆栈信息找出可能存在问题的代码

Jinfo

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

查看 Java 系统参数

Jstat

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 次数

新生代垃圾回收统计

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

新生代内存统计

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

老年代垃圾回收统计

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

老年代内存统计

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

元数据空间统计

MCMN:最小元数据容量
MCMX：最大元数据容量
MC：当前元数据空间大小
CCSMN：最小压缩类空间大小
CCSMX：最大压缩类空间大小
CCSC：当前压缩类空间大小
YGC：年轻代垃圾回收次数
FGC：老年代垃圾回收次数
FGCT：老年代垃圾回收消耗时间
GCT：垃圾回收消耗总时间
S0：幸存 1 区当前使用比例
S1：幸存 2 区当前使用比例
E：伊甸园区使用比例
O：老年代使用比例
M：元数据区使用比例
CCS：压缩使用比例
YGC：年轻代垃圾回收次数
FGC：老年代垃圾回收次数
FGCT：老年代垃圾回收消耗时间
GCT：垃圾回收消耗总时间

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 计算得出。

优化思路其实简单来说就是尽量让每次 Young GC 后的存活对象小于 Survivor 区域的 50%，都留存在年轻代里。尽量别让对象进入老年代。尽量减少

Full GC 的频率，避免频繁 Full GC 对 JVM 性能的影响。

系统频繁 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

 -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFractio

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

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

排查过程

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

jstat -gc 13456 2000 10000

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

1 -Xms1536M -Xmx1536M -Xmn1024M -Xss256K -XX:SurvivorRatio=6 -XX:MetaspaceSiz

2 -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFractio

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

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

元空间不够导致的多余 full gc
显示调用 System.gc()造成多余的 full gc，这种一般线上尽量通过-XX:+DisableExplicitGC 参数禁用，如果加上了这个 JVM 启动参数，那么代码中调用 System.gc()没有任何效果
老年代空间分配担保机制

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

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

代码里全文搜索生成 User 对象的地方(适合只有少数几处地方的情况)
如果生成 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";

 }


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 工具

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

jvisualvm 自动检测死锁

远程连接 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

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

内存泄露到底是怎么回事

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