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

已于 2023-07-15 23:18:00 修改
阅读量309 收藏
点赞数
分类专栏： JVM 文章标签： jvm
于 2023-07-13 23:44:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37174301/article/details/131712308
版权

文章目录

前置启动程序

Jmap

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

jps

在这里插入图片描述

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

在这里插入图片描述
生成的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[][]

堆信息

jmap -heap 21980

在这里插入图片描述

堆内存 dump

jmap -dump:format=b,file=test.hprof 21980

在这里插入图片描述

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

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

示例代码

public class OOMTest {
    public static List 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文件分析
在这里插入图片描述
在这里插入图片描述

Jstack

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

package com.wang.jvm.TuningPractice;

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

}

首先jps 找进程id
在这里插入图片描述
然后jstack加进程id

jstack 23480

在这里插入图片描述
“Thread-1” 线程名
prio=5 优先级=5
tid==0x0000000002c04000 线程id
nid=0x126c 线程对应的本地线程标识nid
java.lang.Thread.State: BLOCKED 线程状态
在这里插入图片描述
还可以用jvisualvm自动检测死锁
在这里插入图片描述
点击dump
在这里插入图片描述

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

public class Math {


    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（top可以查看cpu高的进程）
    在这里插入图片描述
    2.按H，获取每个线程的内存情况 在这里插入图片描述
  2. 找到内存和cpu占用最高的线程tid，比如19664
  3. 转为十六进制得到 0x4cd0，此为线程id的十六进制表示
  4. 执行 jstack 19663|grep -A 10 4cd0，得到线程堆栈信息中 4cd0 这个线程所在行的后面10行，从堆栈中可以发现导致cpu飙高的调用方法 在这里插入图片描述
  5. 查看对应的堆栈信息找出可能存在问题的代码

远程连接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   #临时关闭防火墙

jinfo

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

jinfo -flags <pid>

在这里插入图片描述
查看java系统参数

jinfo -sysprops <pid>

在这里插入图片描述

Jstat

jstat命令可以查看堆内存各部分的使用量，以及加载类的数量。命令的格式如下：
jstat [-命令选项] [vmid] [间隔时间(毫秒)] [查询次数]
注意：使用的jdk版本是jdk8

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

jstat -gc pid

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

堆内存统计

jstat -gccapacity pid

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

新生代垃圾回收统计

jstat -gcnew pid

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

新生代内存统计

jstat -gcnewcapacity pid

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

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毫秒左右。

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

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

为了给大家看效果，我模拟了一个示例程序打印了jstat的结果如下：

jstat -gc 23204 2000  10000

在这里插入图片描述
对于对象动态年龄判断机制导致的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

在这里插入图片描述
优化完发现没什么变化，full gc的次数比minor gc的次数还多了
在这里插入图片描述
我们可以推测下full gc比minor gc还多的原因有哪些？

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

最快速度分析完这些我们推测的原因以及优化后，我们发现young gc和full gc依然很频繁了，而且看到有大量的对象频繁的被挪动到老年代，这种情况我们可以借助jmap命令大概看下是什么对象
在这里插入图片描述
在这里插入图片描述
也可以借助jvisualvm
在这里插入图片描述
查到了有大量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
在这里插入图片描述

内存泄露到底是怎么回事

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

阿里巴巴Arthas

Arthas 是 Alibaba 在 2018 年 9 月开源的 Java 诊断工具。支持 JDK6+， 采用命令行交互模式，可以方便的定位和诊断线上程序运行问题。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测试程序，代码见下方)

java -jar arthas-boot.jar

linux
在这里插入图片描述
windows
在这里插入图片描述

package com.wang;

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

选择进程序号3，进入进程信息操作
在这里插入图片描述
输入dashboard可以查看整个进程的运行情况，线程、内存、GC、运行环境信息：
在这里插入图片描述
输入thread 可以查看线程的详细情况
在这里插入图片描述
输入thread加上线程ID可以查看线程堆栈，我们选择一个cpu高的线程，，下图把我们cpu飚高的代码地方显示出来了
在这里插入图片描述
输入 ==thread -b ==可以查看线程死锁
在这里插入图片描述
输入 jad加类的全名 可以反编译，这样可以方便我们查看线上代码是否是正确的版本
在这里插入图片描述
==使用 ognl 命令可以 ==
在这里插入图片描述
在这里插入图片描述
更多命令使用可以用help命令查看，或查看文档：https://alibaba.github.io/arthas/commands.html#arthas

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

下图中是我截取的JVM刚启动的一部分GC日志
在这里插入图片描述

我们可以看到图中第一行红框，是项目的配置参数。这里不仅配置了打印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都是由于元空间不够导致的，所以我们可以将元空间调大点

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步骤跟我们之前讲过的步骤是类似的

package com.wang.jvm.TuningPractice;

import java.util.ArrayList;

//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 
 */
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

在这里插入图片描述
在日志中我们清除的看到了 “concurrent mode failture” 进入到了 stop the world ,用 serial old 垃圾收集器来回收

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)，可以上传gc文件，然后他会利用可视化的界面来展现GC情况。具体下图所示
在这里插入图片描述
上图我们可以看到年轻代，老年代，以及永久代的内存分配，和最大使用情况。
在这里插入图片描述
上图我们可以看到堆内存在GC之前和之后的变化，以及其他信息。
这个工具还提供基于机器学习的JVM智能优化建议，当然现在这个功能需要付费

在这里插入图片描述
在这里插入图片描述java -XX:+PrintFlagsInitial 表示打印出所有参数选项的默认值
java -XX:+PrintFlagsFinal 表示打印出所有参数选项在运行程序时生效的值

小王爷很帅
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JVM内存模型和性能调优：JVM调优工具详解及调优实战：jstat调优小实战- 第40篇
悟纤学院
05-07 2万+
一、准备工作 准备一个工程jvm-full-gc，核心代码： @RestController public class IndexController { @RequestMapping("/user/process") public String processUserData() throws InterruptedException { ...
JVM调优攻略.pdf
07-27
JVM调优攻略.pdf！
jvm调优工具详解及调优实战
qq_14946371的博客
03-21 417
还不会jvm调优？快进来看看吧。详解如何利用调优工具进行调优，线上内存溢出，cpu飙高，系统卡顿如何解决？
【JVM专题】JVM调优工具详解及调优实战
qq_32681589的博客
07-10 355
线程死锁Java进程CPU使用率爆表等等问题。很多人遇到上述问题通常都是重启解决，然后事后再分析原因。但是我们都知道，这样处理甚至连治标都算不上，有时候重启也不一定有效。其实市面上也有很多可视化分析工具，但是从本质上来说，他们往往都是基于JDK自带的工具来实现的。他们就是：jps，jmap，jstack，jinfo，jstat命令java诊断与调优常用命令jmap、jstack、jstat使用实战》文章Java的jinfo命令使用详解》文章。
JVM-6.JVM调优工具详解及调优实战
最新发布
weixin_42287045的博客
10-14 680
1、Jmap，Jstack，Jinfo命令详解 2、Jvisualvm调优工具实战 3、JVM内存或CPU职高如何快速定位 4、Jstat命令预估JVM运行情况 5、系统频察Full GC导致系统卡顿实战调优 6、内存泄露到底是怎么回事
6——JVM调优工具详解及调优实战
weixin_42044885的博客
02-21 393
此命令可以用来查看内存信息，实例个数，以及占用内存大小。把dump文件装入Jvisvalvm进行分析。Jstack找出占CPU最高的线程堆栈信息。top -p 进程号：显示进程的内存信息。查看正在运行的java应用程序的扩展参数。Jstack加进程id查找死锁。再按H，就展示所有线程。
（JVM学习06）JVM调优工具详解及调优实战
a250029634的博客
04-21 204
JVM调优工具详解及调优实战
JVM-调优工具详解及调优实战
小胡子
03-23 457
JVM-调优工具详解及调优实战
JVM调优工具详解及实战应用
weixin_43134177的博客
09-25 156
Jmap命令可以用来查看内存信息，实例个数以及占用内存大小。3. JVM调优指令调优应用思路。1. JVM调优指令。2. 调优可视化工具。
七：JVM调优工具详解及调优实战
Xx__WangQi的博客
05-19 325
目录 JVM调优工具详解 前置启动程序 Jmap 堆信息 堆内存dump 可以用jvisualvm命令工具导入该dump文件分析 Jstack 远程连接jvisualvm jstack找出占用cpu最高的线程堆栈信息 Jinfo Jstat 垃圾回收统计 堆内存统计 新生代垃圾回收统计 新生代内存统计 老年代垃圾回收统计 老年代内存统计 元数据空间统计 JVM运行情况预估 内存泄露到底是怎么回事 demo代码下载：jvm-full-gc.zip JVM调优工.
JVM内存模型和性能调优：JVM调优工具详解及调优实战：jstat – 第38篇
01-09
在众多的JVM调优工具中，`jstat`（Java Virtual Machine Statistics Monitoring Tool）是一个非常实用的命令行工具，尤其适用于实时监控和分析JVM的状态。 一、`jstat` 命令详解 `jstat`命令允许开发者查看JVM的...
JVM调优篇.pdf
09-12
JVM类加载机制详解 JVM类加载机制是Java虚拟机中的一种机制，它负责加载Java类文件到内存中，以便执行Java程序。类加载机制分为五个阶段：加载、验证、准备、解析和初始化。 加载 加载是类加载过程中的一个阶段，...
06-VIP-JVM调优实战及常量池详解(1)1
08-03
Java虚拟机（JVM）调优是提升Java应用程序性能的关键环节。在JVM中，字符串对象的创建尤其值得关注，因为它们频繁出现且消耗大量的时间和内存。JVM为优化性能和节省内存，对字符串实例化采取了一种特殊策略，即字符...
jvm和gc详解及调优
12-28
10. **实战案例**：书中可能会包含实际项目中的JVM调优案例，帮助读者将理论知识应用到实践中。 通过对这本书的深入学习，Java开发者可以对JVM有更深入的理解，从而编写出更高效、更稳定的代码，并具备解决复杂性能...
06-VIP-JVM调优实战及常量池详解（预习）1
08-03
《JVM调优实战与常量池详解》 在Java开发中，JVM（Java虚拟机）的性能优化是一项至关重要的任务。通过对JVM进行调优，我们可以显著提升应用程序的运行效率，减少内存消耗，避免不必要的垃圾回收（GC）带来的性能...
jvm调优.zip & hotspot源码解读
01-17
5. JVM调优工具详解： 工具如JVisualVM、JConsole、JProfiler等提供了丰富的监控和分析功能，帮助我们了解JVM运行状态，定位性能瓶颈。通过调整JVM参数，如-Xms、-Xmx设置堆大小，-XX:NewRatio调整新生代和老年代...
jvm详解（调优参数等）.doc
06-04
Java 虚拟机（JVM）是Java应用程序的核心组件，负责执行字节码和管理内存。本文将详细解析JVM内存结构及其相关知识点。 首先，JVM内存分为多个区域，其中方法区和堆是线程共享的，而虚拟机栈、本地方法栈和程序...
阿里巴巴java性能调优实战手册
06-12
"阿里巴巴java性能调优实战手册" 本手册旨在为Java开发者提供一份实践性的性能调优指南，帮助他们解决在实际项目中遇到的性能问题。作者通过自己的经验和实践，总结了Java性能调优的重要性和必要性，并分享了自己的...
JVM调优实战：优化策略与案例分析
本文档深入探讨了JVM（Java Virtual Machine）的调优策略，针对JAVA开发人员在实际项目中可能遇到的问题提供了详尽的指导。主要内容包括： 1. JVM基础：首先介绍了JVM的概念，以及它在JAVA应用程序中的关键作用，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值