MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java性能分析工具与实践

2021-10-121.6k 阅读

Java性能分析基础

在Java开发中，性能分析是确保应用程序高效运行的关键环节。性能问题可能出现在各个层面，从算法的复杂度到资源的利用效率，都可能影响到最终的性能表现。为了有效地定位和解决这些问题，我们需要借助各种性能分析工具。

Java性能指标

在深入探讨性能分析工具之前，先明确几个关键的性能指标：

  • 响应时间：指从用户发起请求到系统给出响应的时间间隔。这是衡量用户体验的重要指标，对于交互式应用程序尤为关键。例如，一个在线购物网站的页面加载时间，响应时间过长会导致用户流失。
  • 吞吐量：表示系统在单位时间内处理的请求数量或数据量。对于高并发的应用，如电商平台的订单处理系统，吞吐量是衡量系统处理能力的重要指标。
  • 资源利用率：主要包括CPU、内存、磁盘I/O和网络I/O的使用情况。合理利用资源可以避免系统瓶颈，提高整体性能。例如，过高的CPU使用率可能意味着算法过于复杂或存在死循环；内存泄漏会导致内存使用率不断攀升，最终耗尽系统内存。

Java性能分析工具分类

Java生态系统提供了丰富的性能分析工具，根据其功能和使用场景，可以大致分为以下几类：

  • JDK自带工具：JDK本身包含了一系列实用的性能分析工具，如jps、jstat、jmap、jhat、jstack等。这些工具基于JVM的管理接口（JMX），可以在不引入额外依赖的情况下对Java应用进行基本的性能分析。
  • 可视化工具：如VisualVM、YourKit Java Profiler等，它们提供了直观的图形化界面，方便开发人员快速定位性能问题。这些工具通常支持实时监控、性能数据采集和分析等功能，并且可以生成详细的报告。
  • 代码分析工具：如FindBugs、PMD等，主要用于静态代码分析，通过检查代码中的潜在问题，如不良的编程习惯、可能导致性能问题的代码结构等，帮助开发人员在编码阶段预防性能问题。
  • 应用性能管理（APM）工具：如New Relic、Datadog等，这类工具专注于生产环境的性能监控和管理，可以实时收集应用程序的性能数据，提供端到端的性能追踪，帮助运维和开发团队快速定位和解决生产环境中的性能问题。

JDK自带工具实践

jps（Java Virtual Machine Process Status Tool）

jps工具用于列出正在运行的Java进程及其相关信息，如进程ID（PID）和主类名。它类似于操作系统中的ps命令，但专门针对Java进程。

# 执行jps命令
$ jps
1234 Main
5678 TestApp

上述输出中，1234和5678分别是两个Java进程的PID，Main和TestApp是对应的主类名。jps命令在排查多个Java进程时非常有用，例如在启动了多个Java服务的服务器上，通过jps可以快速找到目标进程的PID，以便进一步使用其他工具进行分析。

jstat（Java Statistics Monitoring Tool）

jstat工具用于收集JVM的各种统计信息，如垃圾回收（GC）统计、类加载统计等。它可以实时监控JVM的运行状态，帮助开发人员了解JVM的性能特征。

# 查看指定进程的GC统计信息，每2秒输出一次，共输出5次
$ jstat -gc 1234 2000 5
 S0C    S1C    S0U    S1U      EC       EU        OC         OU       MC     MU    CCSC   CCSU   YGC     YGCT    FGC    FGCT     GCT
1024.0 1024.0  0.0    0.0   8192.0   4096.0   16384.0    8192.0    1280.0 1024.0 192.0 128.0      1    0.010   0      0.000    0.010
1024.0 1024.0  0.0    0.0   8192.0   4096.0   16384.0    8192.0    1280.0 1024.0 192.0 128.0      1    0.010   0      0.000    0.010
1024.0 1024.0  0.0    0.0   8192.0   4096.0   16384.0    8192.0    1280.0 1024.0 192.0 128.0      1    0.010   0      0.000    0.010
1024.0 1024.0  0.0    0.0   8192.0   4096.0   16384.0    8192.0    1280.0 1024.0 192.0 128.0      1    0.010   0      0.000    0.010
1024.0 1024.0  0.0    0.0   8192.0   4096.0   16384.0    8192.0    1280.0 1024.0 192.0 128.0      1    0.010   0      0.000    0.010

上述输出中，各列含义如下：

  • S0C、S1C：幸存者区0和幸存者区1的容量（KB）。
  • S0U、S1U：幸存者区0和幸存者区1已使用的容量（KB）。
  • EC、EU：伊甸园区的容量和已使用容量（KB）。
  • OC、OU：老年代的容量和已使用容量（KB）。
  • MC、MU：方法区的容量和已使用容量（KB）。
  • CCSC、CCSU：压缩类空间的容量和已使用容量（KB）。
  • YGC、YGCT：年轻代垃圾回收次数和总耗时（秒）。
  • FGC、FGCT：Full GC次数和总耗时（秒）。
  • GCT：垃圾回收总耗时（秒）。

通过观察这些数据，可以了解垃圾回收的频率和耗时，进而优化堆内存的配置。

jmap（Java Memory Map）

jmap工具用于生成JVM的堆转储快照（heap dump），也可以查看堆内存的使用情况。堆转储快照是JVM在某一时刻的堆内存状态的完整记录，包含了所有对象的信息，对于分析内存泄漏和内存使用情况非常有帮助。

# 生成指定进程的堆转储快照
$ jmap -dump:format=b,file=heapdump.hprof 1234
Dumping heap to /path/to/heapdump.hprof ...
Heap dump file created

生成的堆转储快照文件（heapdump.hprof）可以使用其他工具（如VisualVM、Eclipse Memory Analyzer等）进行分析。例如，通过Eclipse Memory Analyzer打开该文件，可以直观地看到哪些对象占用了大量内存，是否存在内存泄漏等问题。

jhat（Java Heap Analysis Tool）

jhat工具用于分析jmap生成的堆转储快照文件。它启动一个HTTP服务器，通过浏览器可以查看堆内存中对象的信息。虽然jhat功能相对有限，但在没有其他更强大的分析工具时，也能提供一些基本的分析功能。

# 使用jhat分析堆转储快照文件
$ jhat heapdump.hprof
Reading from heapdump.hprof...
Dump file created Thu Sep 15 10:12:34 CST 2022
Snapshot read, resolving...
Resolving 19758 objects...
Chasing references, expect 3 dots...
................................................................................
Eliminating duplicate references...
Snapshot resolved.
Started HTTP server on port 7000
Server is ready.

然后在浏览器中访问http://localhost:7000，即可查看堆内存分析结果。

jstack（Java Stack Trace）

jstack工具用于生成Java进程的线程快照，它可以显示每个线程的堆栈跟踪信息，帮助开发人员分析线程的运行状态，如是否存在死锁、线程长时间阻塞等问题。

# 生成指定进程的线程快照
$ jstack 1234 > threaddump.txt

上述命令将线程快照输出到threaddump.txt文件中，通过分析该文件，可以找到线程死锁的线索。例如，以下是一个简单的死锁示例及通过jstack分析的结果。

public class DeadlockExample {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1 holds lock1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("Thread 1 holds lock2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2 holds lock2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("Thread 2 holds lock1");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

运行上述代码后，使用jstack生成线程快照，在输出中可以找到死锁的相关信息：

Found one Java-level deadlock:
=============================
"Thread-1":
  waiting to lock monitor 0x0000000700012345 (object 0x123456789abcdef0, a java.lang.Object),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x0000000700013456 (object 0x0987654321fedcba, a java.lang.Object),
  which is held by "Thread-1"

Java stack information for the threads listed above:
===================================================
"Thread-1":
        at DeadlockExample.lambda$main$1(DeadlockExample.java:18)
        - waiting to lock <0x123456789abcdef0> (a java.lang.Object)
        - locked <0x0987654321fedcba> (a java.lang.Object)
        at DeadlockExample$$Lambda$2/123456789.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)
"Thread-0":
        at DeadlockExample.lambda$main$0(DeadlockExample.java:10)
        - waiting to lock <0x0987654321fedcba> (a java.lang.Object)
        - locked <0x123456789abcdef0> (a java.lang.Object)
        at DeadlockExample$$Lambda$1/987654321.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

Found 1 deadlock.

通过上述信息，可以清晰地看到两个线程相互等待对方持有的锁，从而导致死锁。

可视化工具实践

VisualVM

VisualVM是一款免费的、集成了多个JDK命令行工具的可视化性能分析工具，它可以连接到本地或远程的Java进程，实时监控其性能指标，并进行深入的分析。

  1. 安装和启动：VisualVM通常随JDK一起安装，在JDK的bin目录下可以找到jvisualvm可执行文件。双击运行即可启动VisualVM。
  2. 连接到Java进程：VisualVM启动后，在左侧的“Local”节点下可以看到正在运行的本地Java进程。如果要连接到远程进程，需要在远程JVM启动时添加相关参数，如：
java -Dcom.sun.management.jmxremote \
     -Dcom.sun.management.jmxremote.port=9999 \
     -Dcom.sun.management.jmxremote.authenticate=false \
     -Dcom.sun.management.jmxremote.ssl=false \
     -jar your-application.jar

然后在VisualVM中选择“File” -> “Add JMX Connection”，输入远程服务器的地址和端口（如remote-host:9999），即可连接到远程进程。 3. 性能监控：连接到Java进程后，可以在VisualVM的界面中实时监控CPU、内存、线程等性能指标。例如，在“Monitor”标签页中，可以看到CPU使用率、堆内存使用情况、线程数等信息，并且可以通过图表直观地观察其变化趋势。 4. 线程分析：在“Threads”标签页中，可以查看每个线程的详细信息，包括线程状态（如RUNNABLE、BLOCKED、WAITING等）、堆栈跟踪信息等。对于存在性能问题的线程，通过堆栈跟踪可以定位到具体的代码位置。例如，如果一个线程长时间处于BLOCKED状态，可能是在等待某个锁，通过堆栈跟踪可以找到是在等待哪个对象的锁以及相关的代码逻辑。 5. 采样分析：VisualVM提供了采样分析功能，可以对CPU和内存进行采样。在“Sampler”标签页中，点击“CPU”或“Memory”采样按钮，VisualVM会开始收集相关数据。采样完成后，可以查看哪些方法占用了大量的CPU时间或内存空间。例如，通过CPU采样可以发现某个算法复杂度过高的方法，通过内存采样可以找到创建大量对象的代码位置。

public class PerformanceTest {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            complexCalculation();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("Total time: " + (endTime - startTime) + " ms");
    }

    private static void complexCalculation() {
        // 模拟复杂计算
        double result = 0;
        for (int j = 0; j < 1000; j++) {
            result += Math.sqrt(j);
        }
    }
}

使用VisualVM对上述代码进行CPU采样分析，在采样结果中可以看到complexCalculation方法占用了大量的CPU时间，从而可以针对性地优化该方法。

YourKit Java Profiler

YourKit Java Profiler是一款功能强大的商业性能分析工具，它提供了丰富的功能和高度可定制的界面，能够帮助开发人员深入分析Java应用的性能问题。

  1. 安装和启动：从YourKit官网下载安装包，按照安装向导进行安装。安装完成后，启动YourKit Java Profiler。
  2. 附加到Java进程：YourKit可以通过多种方式附加到Java进程，如本地进程、远程进程、通过代理启动等。对于本地进程，可以直接在启动界面中选择“Attach to running JVM”，然后选择目标Java进程。对于远程进程，需要在远程JVM启动时添加相关代理参数，如：
java -agentpath:/path/to/yjpagent.so=port=10001 \
     -jar your-application.jar

然后在YourKit中选择“Attach to remote JVM”，输入远程服务器的地址和端口（如remote-host:10001），即可附加到远程进程。 3. 性能分析：YourKit提供了全面的性能分析功能，包括CPU分析、内存分析、线程分析、I/O分析等。在CPU分析中，可以通过火焰图等可视化方式直观地看到方法的调用关系和CPU时间消耗情况。例如，以下是一个简单的示例代码及通过YourKit分析的结果。

public class YourKitExample {
    public static void main(String[] args) {
        for (int i = 0; i < 10000; i++) {
            method1();
        }
    }

    private static void method1() {
        method2();
    }

    private static void method2() {
        method3();
    }

    private static void method3() {
        // 模拟一些工作
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

通过YourKit的CPU分析火焰图，可以清晰地看到method3方法占用了大部分的CPU时间，并且可以看到方法之间的调用关系，从而帮助开发人员快速定位性能瓶颈。 在内存分析方面，YourKit可以实时监控对象的创建和销毁情况，找到内存泄漏的源头。通过对象分配图等功能，可以直观地了解哪些类创建了大量的对象，以及这些对象在堆内存中的分布情况。

代码分析工具实践

FindBugs

FindBugs是一款静态代码分析工具，它通过分析Java字节码来查找代码中的潜在问题，包括可能导致性能问题的代码结构。

  1. 安装和使用：可以从FindBugs官网下载FindBugs的安装包，安装完成后，可以通过命令行或集成到IDE中使用。以命令行为例，假设已经将FindBugs添加到系统路径中，可以使用以下命令对一个Java项目进行分析：
findbugs -textui -output bugs.txt your-project.jar

上述命令将分析your-project.jar文件，并将结果输出到bugs.txt文件中。 2. 性能相关问题检测：FindBugs可以检测到一些可能影响性能的问题，例如使用String的+操作符在循环中拼接字符串，这会导致创建大量的中间String对象，影响性能。正确的做法是使用StringBuilder或StringBuffer。

// 不良示例
public class BadStringConcatenation {
    public static void main(String[] args) {
        String result = "";
        for (int i = 0; i < 1000; i++) {
            result += i;
        }
    }
}

FindBugs会检测到上述代码中String拼接的问题，并给出相应的警告信息。开发人员可以根据这些提示优化代码，提高性能。

// 优化示例
public class GoodStringConcatenation {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            sb.append(i);
        }
        String result = sb.toString();
    }
}

PMD

PMD也是一款常用的静态代码分析工具，它可以检查Java代码中的潜在问题，包括性能相关的问题。

  1. 安装和集成：PMD可以通过Maven插件、Gradle插件或直接下载命令行工具的方式使用。以Maven插件为例，在项目的pom.xml文件中添加以下插件配置：
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-pmd-plugin</artifactId>
            <version>3.12.0</version>
            <configuration>
                <rulesets>
                    <ruleset>rulesets/performance.xml</ruleset>
                </rulesets>
                <targetJdk>11</targetJdk>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>check</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

然后在项目根目录下执行mvn pmd:check命令，PMD会根据配置的规则集对项目代码进行分析。 2. 性能规则检查：PMD的性能规则集可以检测到多种性能问题，如使用ArrayList的contains方法在大数据量下性能较低，建议使用HashSet。

// 不良示例
import java.util.ArrayList;
import java.util.List;

public class ArrayListContainsExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            list.add(i);
        }
        boolean contains = list.contains(5000);
    }
}

上述代码中，ArrayList的contains方法时间复杂度为O(n)，在大数据量下性能较差。PMD会检测到这个问题，并提示开发人员使用HashSet，因为HashSet的contains方法时间复杂度为O(1)。

// 优化示例
import java.util.HashSet;
import java.util.Set;

public class HashSetContainsExample {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < 10000; i++) {
            set.add(i);
        }
        boolean contains = set.contains(5000);
    }
}

应用性能管理（APM）工具实践

New Relic

New Relic是一款广泛使用的APM工具，它可以帮助开发人员和运维团队实时监控和管理生产环境中的Java应用性能。

  1. 安装和配置：首先需要在New Relic官网注册账号并创建一个应用。然后在Java应用的服务器上安装New Relic的Java代理。对于Maven项目，可以在pom.xml文件中添加以下依赖：
<dependency>
    <groupId>com.newrelic.agent.java</groupId>
    <artifactId>newrelic-agent</artifactId>
    <version>7.30.0</version>
</dependency>

在应用启动时，通过环境变量或配置文件指定New Relic的许可证密钥等信息。例如，在启动脚本中添加：

export NEW_RELIC_LICENSE_KEY=your-license-key
java -javaagent:/path/to/newrelic-agent.jar -jar your-application.jar
  1. 性能监控和分析：应用启动后，New Relic会开始收集性能数据。在New Relic的控制台中，可以看到应用的整体性能指标，如响应时间、吞吐量、错误率等。通过事务追踪功能，可以深入了解每个请求的处理过程，包括调用了哪些服务、每个服务的响应时间等。例如，在一个微服务架构的应用中，通过New Relic可以快速定位到某个请求在哪个微服务中出现了性能瓶颈。
  2. 异常检测和告警：New Relic可以实时检测应用中的异常情况，如未捕获的异常、响应时间过长等，并通过邮件、短信等方式发送告警通知。开发人员和运维团队可以根据告警信息及时处理性能问题，确保应用的稳定运行。

Datadog

Datadog也是一款功能强大的APM工具，它提供了全面的性能监控和分析功能，支持多种编程语言和框架。

  1. 安装和集成：在Datadog官网注册账号并创建一个应用。然后在Java应用的服务器上安装Datadog的Agent。对于Java应用，可以通过添加Java代理的方式集成Datadog。在pom.xml文件中添加以下依赖：
<dependency>
    <groupId>com.datadoghq</groupId>
    <artifactId>dd-java-agent</artifactId>
    <version>1.44.0</version>
</dependency>

在应用启动时，设置相关环境变量，如：

export DD_AGENT_HOST=agent-host
export DD_API_KEY=your-api-key
export DD_APP_KEY=your-app-key
java -javaagent:/path/to/dd-java-agent.jar -jar your-application.jar
  1. 性能分析功能：Datadog提供了丰富的性能分析功能，包括服务地图、分布式追踪、指标监控等。服务地图可以直观地展示应用中各个服务之间的调用关系，帮助开发人员了解系统架构和性能瓶颈所在。分布式追踪可以深入分析每个请求在不同服务之间的流转过程，精确测量每个阶段的响应时间。通过指标监控，可以实时查看CPU、内存、网络等资源的使用情况，以及应用的业务指标，如订单数量、用户活跃度等。
  2. 可视化和告警：Datadog支持自定义仪表盘，开发人员和运维团队可以根据自己的需求创建可视化界面，展示关键性能指标。同时，Datadog也提供了灵活的告警配置功能，可以根据性能指标的阈值设置告警规则，及时通知相关人员处理性能问题。

综合应用案例

假设我们开发了一个基于Spring Boot的电商应用，在高并发场景下出现了性能问题，响应时间过长，吞吐量下降。下面我们通过综合使用上述性能分析工具来定位和解决问题。

  1. 使用JDK自带工具初步排查：首先使用jps找到应用的进程ID，然后使用jstat观察GC情况，发现年轻代垃圾回收频繁，可能是堆内存配置不合理。接着使用jmap生成堆转储快照，通过分析发现某些对象占用了大量内存，可能存在内存泄漏。
  2. 利用可视化工具深入分析：使用VisualVM连接到应用进程，在“Monitor”标签页中观察到CPU使用率较高，切换到“Sampler”标签页进行CPU采样分析，发现某个业务方法在高并发下执行时间过长。进一步使用YourKit Java Profiler进行更详细的分析，通过火焰图确定了该方法内部的具体代码位置存在性能瓶颈，如数据库查询语句没有优化。
  3. 借助代码分析工具优化代码：使用FindBugs和PMD对代码进行静态分析，发现代码中存在一些不良的编程习惯，如字符串拼接方式不当、集合使用不合理等。根据分析结果对代码进行优化，提高代码的执行效率。
  4. 应用APM工具监控生产环境：在生产环境中部署New Relic或Datadog，实时监控应用的性能指标。通过事务追踪和分布式追踪功能，了解请求在各个微服务之间的流转情况，及时发现新出现的性能问题，并根据告警信息及时处理，确保应用在高并发场景下的稳定运行。

通过综合应用这些性能分析工具，我们可以全面、深入地了解Java应用的性能状况，定位和解决性能问题，提高应用的性能和稳定性。在实际开发中，应根据具体的需求和场景选择合适的工具，并不断积累性能优化的经验，以打造高效、可靠的Java应用。