实战：JVM调优命令&工具

1、查看堆内存每个对象的信息

jmap -histo 12719

输出文件
jmap -histo 12719 > ./log.txt

• num: 序号
• instances: 实例个数
• bytes: 占用空间大小
• class name: 类名称

2、查看堆内存信息

jmap -heap 12719

• Heap Configuration: 分配的内存空间大小
• Heap Usage: 使用的堆内存空间大小

3、导出堆内存快照内存文件，用于使用java visualVM工具查看

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

我们可以在启动Java程序的时候，设置在内存溢出的情况下自动进行导出dump文件（相当于黑匣子）

• -XX:+HeapDumpOnOutOfMemoryError
• -XX:HeapDumpPath=./ （路径）
  eg:

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

4、Jstack 可以查看线程的堆栈情况，或者进程是否存在死锁情况

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");
    }
}

jstack 14660

• Thread-1 线程名
• prio=5 优先级=5
• tid=0x000000001fa9e000 线程id
• nid=0x2d64 线程对应的本地线程标识nid
• java.lang.Thread.State: BLOCKED 线程状态
  ** 死锁打印信息：**

**还可以用jvisualvm自动检测死锁 **

5、 远程连接jvisualvm

在启动java程序时候记得开启JMX的端口号配置：
java ‐Dcom.sun.management.jmxremote.port=8888 远程jmx的端口号

• ‐Djava.rmi.server.hostname=192.168.50.60 远程机器的IP，也就是Linux服务机器的IP
• ‐Dcom.sun.management.jmxremot e.ssl=false
• ‐Dcom.sun.management.jmxremote.authenticate=false
• ‐jar microservice‐eureka‐server.jar
  但是这种方式一般不使用，因为生产暴露这种端口是很危险的。

然后利用工具连接：

6、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）第一步定位CPU飙升的进程
top -p 19663

键盘 按 H, 获取每个线程的内存情况

2）找到内存和CPU占用最高的线程PID，比如19664（线程号）

3) 转为十六进制得到 0x4cd0，此为线程id的十六进制表示

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

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

jinfo -flags 14124 查看JVM参数

jinfo -sysprops 14124 查看java系统参数

7、jstat 查看堆内存各部分的使用量

1）垃圾回收统计
jstat -gc 13213

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

2）堆内存统计

jstat -gccapacity 13213

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

3）新生代垃圾回收统计

jstat -gcnew 13213

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

4） 新生代内存统计

jstat -gcnewcapactity 13213

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

5） 老生代垃圾回收统计

6） 老生代内存统计

7） 元数据空间统计

**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性能的影响。

8、实战案例

系统频繁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毫秒左右。

1）JVM参数设置如下：

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

大家可以结合对象挪动到老年代那些规则推理下我们这个程序可能存在的一些问题 经过分析感觉可能会由于对象动态年龄判断机制导致full gc较为频繁

对于对象动态年龄判断机制导致的full gc较为频繁可以先试着优化下JVM参数，把年轻代适当调大点：
‐Xms1536M ‐Xmx1536M ‐Xmn1024M ‐Xss256K ‐XX:SurvivorRatio=6 ‐XX:MetaspaceSize=256M ‐XX:MaxMetaspaceSize=256M 2 ‐XX:+UseParNewGC ‐XX:+UseConcMarkSweepGC ‐XX:CMSInitiatingOccupancyFraction=92 ‐XX:+UseCMSInitiatingOccupancyOnly

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

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

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

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

3、老年代空间分配担保机制 最快速度分析完这些我们推测的原因以及优化后，我们发现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 g

本文由mdnice多平台发布