吃透 JVM 诊断方法与工具使用

作者：EquatorCoco

2024-09-12
福建
本文字数：12117 字
阅读完需：约 40 分钟

JVM（Java 虚拟机）是 Java 程序运行的基础环境，它提供了内存管理、线程管理和性能监控等功能。吃透 JVM 诊断方法，可以帮助开发者更有效地解决 Java 应用在运行时遇到的问题。以下是一些常见的 JVM 诊断方法：

1、使用 JConsole:

JConsole 是一个可视化监控工具，可以连接到本地或远程的 JVM 实例，查看内存使用情况、线程状态、类加载信息等。

2、使用 VisualVM:

VisualVM 提供了更丰富的功能，包括线程分析、内存泄漏分析、GC 日志分析等。

3、使用 jstack:

jstack 是一个命令行工具，可以生成 Java 线程的快照，用于分析线程的状态和死锁问题。

4、使用 jmap:

jmap 可以用来生成堆转储快照（heap dump），分析内存使用情况，查找内存泄漏。

5、使用 jstat:

jstat 提供了运行中的 JVM 实例的性能数据，包括类加载、内存、垃圾回收等统计信息。

6、使用 jcmd:

jcmd 是一个多功能命令行工具，可以执行各种诊断命令，如获取线程栈、内存信息等。

7、分析 GC 日志:

垃圾收集器（GC）的日志包含了垃圾回收的详细信息，通过分析这些日志可以了解 GC 的行为和性能瓶颈。

8、使用 MAT（Memory Analyzer Tool）:

MAT 是一个强大的堆转储分析工具，可以帮助开发者分析内存使用情况，查找内存泄漏。

9、使用 Profilers:

使用性能分析工具（如 YourKit, JProfiler）可以帮助开发者了解应用程序的性能瓶颈。

通过这些方法，你可以更深入地了解 JVM 的内部工作机制，从而更有效地诊断和解决 Java 应用中的问题。下面让我们一一来讲解使用方法。

1. 使用 JConsole

模拟示例代码来演示 JConsole 工具的使用，我们可以创建一个简单的 Java 应用程序，它将展示内存使用、线程监控和 GC 活动。然后，我们将使用 JConsole 来监控这个应用程序。

示例 Java 应用程序代码

import java.util.ArrayList;import java.util.List;
public class JConsoleDemo {    private static final int LIST_SIZE = 1000;    private static List<Object> list = new ArrayList<>();
    public static void main(String[] args) throws InterruptedException {        // 模拟内存使用增长        for (int i = 0; i < 5; i++) {            list.add(new byte[1024 * 1024]); // 添加1MB数据            Thread.sleep(1000); // 模拟延迟            System.out.println("Memory used: " + (i + 1) + "MB");        }
        // 模拟线程活动        Thread thread1 = new Thread(() -> {            for (int i = 0; i < 10; i++) {                System.out.println("Thread 1 is running");                try {                    Thread.sleep(500);                } catch (InterruptedException e) {                    Thread.currentThread().interrupt();                }            }        });
        Thread thread2 = new Thread(() -> {            while (true) {                synchronized (JConsoleDemo.class) {                    System.out.println("Thread 2 is running");                }                try {                    Thread.sleep(500);                } catch (InterruptedException e) {                    Thread.currentThread().interrupt();                }            }        });
        thread1.start();        thread2.start();
        // 模拟GC活动        Runtime.getRuntime().gc();    }}

复制代码

使用 JConsole 监控示例应用程序

1、编译并运行示例应用程序：

使用javac JConsoleDemo.java编译 Java 代码。
使用java -classpath . JConsoleDemo运行应用程序。

2、启动 JConsole：

在命令行中输入jconsole并回车。

3、连接到应用程序：

在 JConsole 中，选择"连接"，然后从列表中选择正在运行的 JConsoleDemo 应用程序。

4、监控内存使用：

在"内存"标签页中，观察堆内存的变化。你应该能看到随着程序运行，内存使用量逐渐增加。

5、监控线程状态：

切换到"线程"标签页，查看线程的活动。注意线程 1 和线程 2 的运行情况。

6、分析线程死锁：

如果线程 2 在同步块中等待，而线程 1 尝试获取同一个锁，这将导致死锁。使用"Find Deadlocked Threads"功能来检测。

7、监控 GC 活动：

回到"内存"标签页，查看 GC 的统计信息，如 GC 次数和 GC 时间。

8、生成堆转储：

如果需要进一步分析内存使用情况，可以在"内存"标签页中使用"Dump Heap"功能生成堆转储。

9、监控 MBeans：

如果应用程序注册了自定义 MBeans，可以在"MBeans"标签页中查看它们。

通过这个示例，你可以了解如何使用 JConsole 来监控 Java 应用程序的内存使用、线程状态和 GC 活动。这些信息对于诊断性能问题和优化应用程序至关重要。

2. 使用 VisualVM

VisualVM 是一个强大的多合一工具，它提供了对 Java 应用程序的深入分析，包括 CPU、内存、线程和 GC 等。下面是一个简单的 Java 应用程序示例，它将展示如何使用 VisualVM 来监控和分析。

示例 Java 应用程序代码

public class VisualVMDemo {    private static final int ARRAY_SIZE = 1000;    private static final Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {        // 创建一个大数组以模拟内存使用        Object[] largeArray = new Object[ARRAY_SIZE];
        // 创建线程以模拟CPU使用和线程活动        Thread cpuIntensiveThread = new Thread(() -> {            for (int i = 0; i < 10000; i++) {                // 模拟CPU密集型任务                for (int j = 0; j < 100000; j++) {                    // 空循环体                }            }        });
        // 创建线程以模拟线程死锁        Thread thread1 = new Thread(() -> {            synchronized (lock) {                System.out.println("Thread 1 acquired lock");                try {                    Thread.sleep(500);                } catch (InterruptedException e) {                    Thread.currentThread().interrupt();                }                synchronized (VisualVMDemo.class) {                    System.out.println("Thread 1 acquired second lock");                }            }        });
        Thread thread2 = new Thread(() -> {            synchronized (VisualVMDemo.class) {                System.out.println("Thread 2 acquired second lock");                try {                    Thread.sleep(500);                } catch (InterruptedException e) {                    Thread.currentThread().interrupt();                }                synchronized (lock) {                    System.out.println("Thread 2 acquired lock");                }            }        });
        // 启动线程        cpuIntensiveThread.start();        thread1.start();        thread2.start();
        // 模拟内存泄漏        while (true) {            // 持续创建对象但不释放引用            largeArray[(int) (Math.random() * ARRAY_SIZE)] = new Object();            Thread.sleep(10);        }    }}

复制代码

使用 VisualVM 监控示例应用程序

1、编译并运行示例应用程序：

使用javac VisualVMDemo.java编译 Java 代码。
使用java -classpath . VisualVMDemo运行应用程序。

2、启动 VisualVM：

在命令行中输入visualvm并回车。

3、连接到应用程序：

VisualVM 会自动检测到运行中的 Java 应用程序。如果没有自动检测到，你可以使用"添加 JMX 连接"手动添加。

4、监控 CPU 使用：

在"监视"选项卡中，查看 CPU 的"当前"和"历史"使用情况。

5、监控内存使用：

在"监视"选项卡中，查看堆内存和非堆内存的使用情况。

6、分析内存泄漏：

使用"内存"选项卡，点击"GC"按钮来触发垃圾回收，然后观察是否有对象没有被回收，这可能表明内存泄漏。

7、分析线程死锁：

在"线程"选项卡中，查找死锁的线程。VisualVM 会显示死锁的线程和它们的调用栈。

8、分析 GC 活动：

在"监视"选项卡中，查看 GC 的统计信息，如 GC 次数、GC 持续时间等。

9、生成堆转储：

在"内存"选项卡中，点击"堆转储"按钮来生成堆转储文件，然后使用分析工具进一步分析。

10、分析采样 CPU Profile：

在"CPU"选项卡中，启动 CPU 分析器，查看哪些方法占用了最多的 CPU 时间。

11、查看应用程序的类加载信息：

在"类"选项卡中，查看已加载的类和它们的加载时间。

通过这个示例，你可以了解 VisualVM 的多种功能，包括 CPU 分析、内存分析、线程分析和 GC 分析等。这些工具可以帮助你诊断和优化 Java 应用程序的性能问题。

3. 使用 jstack

jstack是一个命令行工具，它用于生成 Java 线程的堆栈跟踪，这对于分析线程状态和死锁问题非常有用。下面是一个简单的 Java 应用程序示例，它将演示如何使用jstack来获取线程的堆栈跟踪。

示例 Java 应用程序代码

public class JStackDemo {    public static void main(String[] args) {        // 创建一个示例对象，用于在堆栈跟踪中识别        Object exampleObject = new Object();
        // 创建两个线程，它们将尝试获取同一个锁，导致死锁        Thread thread1 = new Thread(new DeadlockDemo("Thread-1", exampleObject, true));        Thread thread2 = new Thread(new DeadlockDemo("Thread-2", exampleObject, false));
        thread1.start();        thread2.start();    }}
class DeadlockDemo implements Runnable {    private final String name;    private final Object lock1;    private final boolean lockOrder;
    public DeadlockDemo(String name, Object lock1, boolean lockOrder) {        this.name = name;        this.lock1 = lock1;        this.lockOrder = lockOrder;    }
    @Override    public void run() {        System.out.println(name + " started");
        if (lockOrder) {            synchronized (lock1) {                System.out.println(name + " acquired lock1");                try {                    Thread.sleep(500); // 模拟工作                } catch (InterruptedException e) {                    Thread.currentThread().interrupt();                }                synchronized (JStackDemo.class) {                    System.out.println(name + " acquired lock2");                }            }        } else {            synchronized (JStackDemo.class) {                System.out.println(name + " acquired lock2");                try {                    Thread.sleep(500); // 模拟工作                } catch (InterruptedException e) {                    Thread.currentThread().interrupt();                }                synchronized (lock1) {                    System.out.println(name + " acquired lock1");                }            }        }    }}

复制代码

使用`jstack`获取线程堆栈跟踪

1、编译并运行示例应用程序：

使用javac JStackDemo.java编译 Java 代码。
使用java -classpath . JStackDemo运行应用程序。

2、获取 Java 进程 ID：

在命令行中使用jps命令查看所有 Java 进程及其 PID。

3、使用jstack获取堆栈跟踪：

假设你的 Java 应用程序的 PID 是 1234，使用以下命令获取线程堆栈跟踪：

jstack 1234

复制代码

4、分析输出：

jstack命令将输出所有线程的堆栈跟踪。你可以查看每个线程的状态和它们调用的方法。

5、查找死锁：

在输出中，jstack会特别标记死锁的线程，并显示死锁循环。例如：

    Found one Java-level deadlock:    ===================    "Thread-1":        at JStackDemo$DeadlockDemo.run(JStackDemo.java:23)        - waiting to lock monitor 0x00000007f7e8b8400 (object 0x00000007f7e8b8420, a java.lang.Class)        - locked ownable synchronizer 0x00000007f7e8b8420 (a java.util.concurrent.locks.ReentrantLock$NonfairSync)    "Thread-2":        at JStackDemo$DeadlockDemo.run(JStackDemo.java:23)        - waiting to lock monitor 0x00000007f7e8b8420 (object 0x00000007f7e8b8420, a java.lang.Class)        - locked ownable synchronizer 0x00000007f7e8b8400 (a java.util.concurrent.locks.ReentrantLock$NonfairSync)    Java stack information for the threads listed above:    ===================================================    "Thread-1":            at JStackDemo$DeadlockDemo.run(JStackDemo.java:23)            - waiting to lock <0x00000007f7e8b8400>            - locked <0x00000007f7e8b8420>    "Thread-2":            at JStackDemo$DeadlockDemo.run(JStackDemo.java:23)            - waiting to lock <0x00000007f7e8b8420>            - locked <0x00000007f7e8b8400>

复制代码

6、解决死锁：

根据jstack的输出，你可以分析死锁的原因，并修改代码来避免死锁，例如通过确保所有线程以相同的顺序获取锁。

通过这个示例，你可以看到jstack是一个强大的工具，可以帮助你快速诊断线程问题和死锁。

4. 使用 jmap

jmap是一个命令行实用程序，用于生成 Java 堆转储快照或连接到正在运行的 Java 虚拟机（JVM）并检索有关堆的有用信息。下面是一个简单的 Java 应用程序示例，它将演示如何使用jmap来生成堆转储文件。

示例 Java 应用程序代码

public class JmapDemo {    private static final int LIST_SIZE = 10000;
    public static void main(String[] args) {        List<Object> list = new ArrayList<>();
        // 填充列表以使用大量内存        for (int i = 0; i < LIST_SIZE; i++) {            list.add(new byte[1024]); // 每个元素1KB        }
        // 为了保持对象活跃，防止被GC回收        keepReference(list);    }
    private static void keepReference(List<Object> list) {        // 此方法保持对list的引用，防止其被回收        while (true) {            try {                // 让线程休眠，模拟长时间运行的服务                Thread.sleep(5000);            } catch (InterruptedException e) {                Thread.currentThread().interrupt();            }        }    }}

复制代码

使用`jmap`生成堆转储文件

1、编译并运行示例应用程序：

使用javac JmapDemo.java编译 Java 代码。
使用java -classpath . JmapDemo运行应用程序。

2、获取 Java 进程 ID：

在命令行中使用jps命令查看所有 Java 进程及其 PID。

3、使用jmap生成堆转储：

假设你的 Java 应用程序的 PID 是 1234，使用以下命令生成堆转储文件：

jmap -dump:format=b,file=heapdump.hprof 1234

复制代码

这个命令会生成一个名为heapdump.hprof的堆转储文件。

4、分析堆转储文件：

使用 MAT（Memory Analyzer Tool）或其他堆分析工具打开heapdump.hprof文件，分析内存使用情况和潜在的内存泄漏。

5、使用jmap打印堆信息：

如果你只需要查看堆的概览信息，可以使用：

jmap -heap 1234

复制代码

这将打印出堆的详细信息，包括使用的内存、最大内存、GC 策略等。

6、使用jmap打印类加载信息：

要查看类加载器的统计信息，可以使用：

jmap -clstats 1234

复制代码

这将打印出已加载的类的数量和相关信息。

7、使用jmap打印 finalizer 队列：

如果你怀疑有对象因为等待finalize()方法而被保留在内存中，可以使用：

jmap -finalizerinfo 1234

复制代码

这将打印出等待finalize()方法的对象的信息。

通过这个示例，你可以看到jmap是一个有用的工具，可以帮助你诊断内存相关问题，如内存泄漏和高内存使用。生成的堆转储文件可以进一步使用其他分析工具进行深入分析。

5. 使用 jstat

jstat是 JDK 提供的一个命令行工具，用于实时监控 JVM 的性能指标，如类加载、内存、垃圾收集等。下面是一个简单的 Java 应用程序示例，它将演示如何使用jstat来监控 JVM 的运行情况。

示例 Java 应用程序代码

public class JstatDemo {    private static final int ARRAY_SIZE = 1000000;    private static final byte[] data = new byte[1024 * 1024]; // 1MB数组
    public static void main(String[] args) {        // 模拟内存分配        for (int i = 0; i < ARRAY_SIZE; i++) {            if (i % 100000 == 0) {                // 模拟间歇性的内存分配                data = new byte[1024 * 1024];            }        }
        // 模拟长时间运行的服务        while (true) {            try {                Thread.sleep(1000); // 休眠1秒            } catch (InterruptedException e) {                Thread.currentThread().interrupt();            }        }    }}

复制代码

使用`jstat`监控 JVM 性能指标

1、编译并运行示例应用程序：

使用javac JstatDemo.java编译 Java 代码。
使用java -classpath . JstatDemo运行应用程序。

2、获取 Java 进程 ID：

在命令行中使用jps命令查看所有 Java 进程及其 PID。

3、使用jstat监控 GC 活动：

假设你的 Java 应用程序的 PID 是 1234，使用以下命令监控 GC 活动：

jstat -gc 1234

复制代码

这将显示 GC 相关的统计信息，如 S0C、S1C、S0U、S1U（年轻代大小和使用情况）、EC、EU、OC、OU、MC、MU 等。

4、监控类加载信息：

使用以下命令监控类加载器的统计信息：

jstat -class 1234

复制代码

这将显示已加载的类数量、已卸载的类数量等信息。

5、监控编译方法信息：

使用以下命令监控 JIT 编译器的统计信息：

jstat -compiler 1234

复制代码

这将显示编译任务的数量、编译时间等信息。

6、监控内存使用情况：

使用以下命令监控内存使用情况：

jstat -gcutil 1234

复制代码

这将显示堆内存的利用率，包括年轻代和老年代。

7、监控线程活动：

使用以下命令监控线程的统计信息：

jstat -thread 1234

复制代码

这将显示线程总数、存活线程数、峰值线程数等信息。

8、监控同步阻塞信息：

使用以下命令监控同步阻塞信息：

jstat -sync 1234

复制代码

这将显示同步操作的统计信息，如监视器锁的争用情况。

通过这个示例，你可以看到jstat是一个实时监控工具，可以帮助你了解 JVM 的运行状况，特别是在性能调优和故障排查时非常有用。通过监控不同的性能指标，你可以快速定位问题并采取相应的措施。

6. 使用 jcmd

jcmd 是一个多功能的命令行工具，用于执行管理和诊断命令，获取有关 Java 虚拟机（JVM）和 Java 应用程序的信息。下面是一个简单的 Java 应用程序示例，它将演示如何使用 jcmd 来监控和管理 JVM 的运行情况。

示例 Java 应用程序代码

public class JcmdDemo {    private static final int LIST_SIZE = 10000;
    public static void main(String[] args) {        List<Object> list = new ArrayList<>();
        // 填充列表以使用大量内存        for (int i = 0; i < LIST_SIZE; i++) {            list.add(new byte[1024]); // 每个元素1KB        }
        // 模拟长时间运行的服务        while (true) {            try {                Thread.sleep(1000); // 休眠1秒            } catch (InterruptedException e) {                Thread.currentThread().interrupt();            }        }    }}

复制代码

使用`jcmd`监控和管理 JVM

1、编译并运行示例应用程序：

使用javac JcmdDemo.java编译 Java 代码。
使用java -classpath . JcmdDemo运行应用程序。

2、获取 Java 进程 ID：

在命令行中使用jps命令查看所有 Java 进程及其 PID。

3、使用jcmd获取 JVM 信息：

假设你的 Java 应用程序的 PID 是 1234，使用以下命令获取 JVM 的基本信息：

jcmd 1234 Help

复制代码

这将显示所有可用的jcmd命令及其说明。

4、获取线程堆栈跟踪：

使用以下命令获取所有线程的堆栈跟踪：

jcmd 1234 Thread.print

复制代码

这将输出每个线程的调用栈。

5、监控 GC 活动：

使用以下命令监控 GC 活动：

jcmd 1234 GC.class_histogram

复制代码

这将显示所有加载的类的统计信息。

6、生成堆转储文件：

使用以下命令生成堆转储文件：

jcmd 1234 GC.heap_dump /path/to/heapdump.hprof

复制代码

这将生成一个名为heapdump.hprof的堆转储文件，你可以使用 MAT（Memory Analyzer Tool）或其他堆分析工具进行分析。

7、监控内存使用情况：

使用以下命令监控内存使用情况：

jcmd 1234 GC.heap_info

复制代码

这将显示堆内存的详细信息，包括年轻代和老年代的大小。

8、监控线程状态：

使用以下命令监控线程状态：

jcmd 1234 Thread.print

复制代码

这将显示所有线程的状态和堆栈跟踪。

9、监控编译任务：

使用以下命令监控编译任务：

jcmd 1234 Compiler.code

复制代码

这将显示 JIT 编译器编译的代码信息。

10、监控类加载信息：

使用以下命令监控类加载信息：

jcmd 1234 ClassLoader.stats

复制代码

这将显示类加载器的统计信息。

通过这个示例，你可以看到jcmd是一个强大的工具，可以执行多种管理和诊断命令。它不仅可以帮助你监控 JVM 的运行情况，还可以生成堆转储文件进行深入分析。

7. 分析 GC 日志

分析 GC（垃圾收集）日志是监控和优化 Java 应用程序性能的重要手段之一。GC 日志包含了 JVM 执行垃圾收集时的详细信息，比如收集前后的堆内存使用情况、收集所花费的时间等。下面是一个简单的 Java 应用程序示例，它将演示如何产生 GC 日志，并使用分析工具来解读这些日志。

示例 Java 应用程序代码

import java.util.ArrayList;import java.util.List;
public class GcLogDemo {    private static final int LIST_SIZE = 10000;
    public static void main(String[] args) {        List<Byte[]> list = new ArrayList<>();
        // JVM参数设置，以产生GC日志        // -Xlog:gc*:file=gc.log 表示记录所有GC相关日志到gc.log文件        // -Xms100m -Xmx100m 设置JVM的初始堆大小和最大堆大小为100MB        // JVM参数应放在java命令中，例如：        // java -Xlog:gc*:file=gc.log -Xms100m -Xmx100m -classpath . GcLogDemo
        for (int i = 0; i < LIST_SIZE; i++) {            // 分配内存，触发GC            list.add(new Byte[1024]);        }
        // 让GC有机会执行        while (true) {            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                Thread.currentThread().interrupt();            }        }    }}

复制代码

使用分析工具解读 GC 日志

1、编译并运行示例应用程序：

使用javac GcLogDemo.java编译 Java 代码。
运行应用程序时，确保包含了产生 GC 日志的 JVM 参数，如上面注释中所示。

2、产生 GC 日志：

运行应用程序一段时间后，它将产生 GC 日志到指定的文件（例如gc.log）。

3、使用 GC 日志分析工具：

可以使用多种工具来分析 GC 日志，例如 GCViewer、GCEasy、jClarity 等。
以 GCViewer 为例，你可以将 GC 日志文件拖放到 GCViewer 应用程序中，或者使用File -> Open来加载日志文件。

4、分析 GC 日志内容：

在 GCViewer 中，你可以看到 GC 的概览，包括 GC 的类型（Minor GC、Major GC、Full GC 等）。
观察 GC 发生的时间点，以及每次 GC 所占用的时间。
分析堆内存的使用情况，包括 Eden 区、Survivor 区、老年代等。

5、识别性能瓶颈：

如果发现 GC 时间过长或者频繁发生，这可能是性能瓶颈的迹象。
分析 GC 日志可以帮助你确定是否需要调整 JVM 的内存设置或垃圾收集器策略。

6、调整 JVM 参数：

根据 GC 日志的分析结果，你可能需要调整堆大小、Eden 和 Survivor 区的比例、垃圾收集器类型等参数。

7、重新运行并监控：

在调整了 JVM 参数后，重新运行应用程序并监控 GC 日志，以验证性能是否有所改善。

通过这个示例，你可以看到如何通过产生和分析 GC 日志来监控和优化 Java 应用程序的垃圾收集性能。这对于确保应用程序的稳定性和响应性至关重要。

8. 使用 MAT（Memory Analyzer Tool）

MAT（Memory Analyzer Tool）是一个开源的 Java 堆分析器，它可以帮助我们发现内存泄漏和优化内存使用。下面是一个简单的 Java 应用程序示例，它将产生一个堆转储文件，然后我们可以使用 MAT 来分析这个文件。

示例 Java 应用程序代码

import java.util.ArrayList;import java.util.List;
public class MatDemo {    private static List<Object> leakedObjects = new ArrayList<>();
    public static void main(String[] args) {        // 模拟内存泄漏：不断创建新对象，并保留对它们的引用        for (int i = 0; i < 10000; i++) {            leakedObjects.add(new byte[1024]); // 每个元素1KB        }
        // 触发堆转储，可以通过-XX:+HeapDumpOnOutOfMemoryError参数自动触发        // 或者通过程序调用System.gc()来建议JVM进行垃圾收集        // 然后使用jmap工具手动触发堆转储        try {            System.out.println("Initiating heap dump - please wait...");            // 假设jmap工具已经生成了堆转储文件 matdemo.hprof            // 如果需要在程序中触发，可以使用Runtime.getRuntime().gc();            // 然后调用Thread.sleep(5000); 让GC有足够的时间执行            // 接着使用jmap生成堆转储：jmap -dump:format=b,file=matdemo.hprof <pid>            Thread.sleep(5000);        } catch (InterruptedException e) {            Thread.currentThread().interrupt();        }
        // 程序将保持运行，以等待MAT分析        while (true) {            try {                Thread.sleep(60000); // 休眠60秒            } catch (InterruptedException e) {                Thread.currentThread().interrupt();            }        }    }}

复制代码

使用 MAT 分析堆转储文件

1、编译并运行示例应用程序：

使用javac MatDemo.java编译 Java 代码。
运行应用程序，确保通过 JVM 参数或jmap工具生成了堆转储文件，例如matdemo.hprof。

2、启动 MAT：

下载并启动 MAT 工具。

3、加载堆转储文件：

在 MAT 中，选择"File" -> "Open Heap Dump"，然后选择之前生成的matdemo.hprof文件。

4、分析内存使用情况：

MAT 将分析堆转储文件，并展示概览信息，包括内存使用概览、类实例、GC roots 等。

5、查找内存泄漏：

使用 MAT 的"Analyzer" -> "Run"功能，MAT 将分析可能的内存泄漏。
检查"Leak Suspects Report"，它将列出可能的内存泄漏对象。

6、查看对象的引用情况：

在"Dominator Tree"视图中，可以查看哪些对象占用了最多的内存。
在"Reference Chain"视图中，可以查看对象被引用的路径。

7、分析特定的对象：

如果你怀疑某个对象存在内存泄漏，可以在"Classes"视图中找到这个类，然后双击实例查看详细信息。

8、使用 OQL 查询：

MAT 支持对象查询语言（OQL），你可以使用 OQL 来查询特定的对象集合或模式。

9、导出和保存分析结果：

你可以将分析结果导出为报告，以供进一步分析或记录。

通过这个示例，你可以看到 MAT 是一个功能强大的工具，可以帮助你分析 Java 堆转储文件，发现内存泄漏和优化内存使用。MAT 提供了丰富的视图和查询功能，使得分析过程更加高效和深入。

9. 使用 Profilers

Profilers 是一类用于性能分析的工具，它们可以帮助开发者识别应用程序中的性能瓶颈。下面是一个简单的 Java 应用程序示例，它将演示如何使用 Profilers 工具（如 JProfiler 或 YourKit Java Profiler）来监控和分析应用程序的性能。

示例 Java 应用程序代码

public class ProfilerDemo {    private static final int NUM_ITERATIONS = 1000000;
    public static void main(String[] args) {        // 执行一些计算密集型的任务        long result = computeSum(0, NUM_ITERATIONS);
        // 模拟长时间运行的服务        while (true) {            try {                Thread.sleep(1000); // 休眠1秒            } catch (InterruptedException e) {                Thread.currentThread().interrupt();            }        }    }
    private static long computeSum(long start, long end) {        long sum = 0;        for (long i = start; i < end; i++) {            sum += i;        }        return sum;    }}

复制代码

使用 Profilers 工具监控和分析性能

1、编译并运行示例应用程序：

使用javac ProfilerDemo.java编译 Java 代码。
运行应用程序时，确保启动了 Profilers 工具，并将应用程序附加到 Profilers 中。

2、附加 Profilers 到应用程序：

打开 JProfiler 或 YourKit Java Profiler 等 Profilers 工具。
在 Profilers 中选择“附加到应用程序”，并选择正在运行的ProfilerDemo进程。

3、监控 CPU 使用情况：

在 Profilers 的 CPU Profiling 视图中，监控应用程序的 CPU 使用情况。
识别占用 CPU 时间最多的方法，这可能是性能瓶颈。

4、分析内存使用：

使用内存分析功能来监控应用程序的内存使用情况。
查看内存分配情况，识别内存泄漏或高内存消耗的类。

5、识别线程活动和锁争用：

监控线程活动，查看线程的状态和锁的使用情况。
识别死锁或线程争用，这可能影响应用程序的响应时间。

6、执行采样分析：

使用 Profilers 的采样分析功能来收集一段时间内的调用数据。
分析采样结果，找出热点方法和调用路径。

7、使用调用树视图：

查看调用树视图，了解方法调用的层次结构和时间消耗。

8、分析方法执行情况：

识别执行时间最长的方法，并查看它们的调用者和被调用者。

9、优化代码：

根据分析结果，优化代码以提高性能，例如通过减少不必要的计算、改进数据结构或算法。

10、重新分析优化后的代码：

在优化代码后，重新运行 Profilers 分析，验证性能改进。

通过这个示例，你可以看到 Profilers 工具如何帮助开发者监控和分析 Java 应用程序的性能。通过识别性能瓶颈和内存问题，开发者可以采取相应的优化措施来提高应用程序的效率和响应速度。

10. 最后

在实际工作中，我们还需要监控系统资源，比如监控 CPU、内存、磁盘 I/O 和网络等系统资源的使用情况，以确定是否是系统资源限制导致的问题。

文章转载自：威哥爱编程
原文链接：https://www.cnblogs.com/wgjava/p/18336069
体验地址：http://www.jnpfsoft.com/?from=infoq

发布于: 刚刚阅读数: 4

EquatorCoco

关注

还未添加个人签名 2023-06-19 加入

还未添加个人简介

发布

暂无评论

创作场景

吃透 JVM 诊断方法与工具使用

1. 使用 JConsole

示例 Java 应用程序代码

使用 JConsole 监控示例应用程序

2. 使用 VisualVM

示例 Java 应用程序代码

使用 VisualVM 监控示例应用程序

3. 使用 jstack

示例 Java 应用程序代码

使用jstack获取线程堆栈跟踪

4. 使用 jmap

示例 Java 应用程序代码

使用jmap生成堆转储文件

5. 使用 jstat

示例 Java 应用程序代码

使用jstat监控 JVM 性能指标

6. 使用 jcmd

示例 Java 应用程序代码

使用jcmd监控和管理 JVM

7. 分析 GC 日志

示例 Java 应用程序代码

使用分析工具解读 GC 日志

8. 使用 MAT（Memory Analyzer Tool）

示例 Java 应用程序代码

使用 MAT 分析堆转储文件

9. 使用 Profilers

示例 Java 应用程序代码

使用 Profilers 工具监控和分析性能

10. 最后

EquatorCoco

评论

使用`jstack`获取线程堆栈跟踪

使用`jmap`生成堆转储文件

使用`jstat`监控 JVM 性能指标

使用`jcmd`监控和管理 JVM