Java JMH：深入理解与高效使用

简介

在 Java 开发中，性能调优是一项至关重要的工作。为了准确评估代码的性能，我们需要可靠的基准测试工具。Java Microbenchmark Harness（JMH）就是这样一个由 OpenJDK 团队开发的专门用于 Java 代码微基准测试的工具。它可以帮助开发者编写、运行和分析高性能代码的基准测试，提供准确、可靠的性能数据。本文将详细介绍 JMH 的基础概念、使用方法、常见实践以及最佳实践，帮助读者深入理解并高效使用 JMH。

目录

1. Java JMH 基础概念
2. Java JMH 使用方法
3. Java JMH 常见实践
4. Java JMH 最佳实践
5. 小结
6. 参考资料

Java JMH 基础概念

基准测试

基准测试是一种测量和评估软件性能的方法，通过运行特定的代码片段，收集其执行时间、吞吐量等性能指标，以评估代码的性能表现。在 Java 中，基准测试可以帮助我们找出性能瓶颈，优化代码。

JMH 核心概念

• 基准测试方法（Benchmark Method）：被 @Benchmark 注解标记的方法，是 JMH 执行性能测试的核心部分。
• 基准测试类（Benchmark Class）：包含基准测试方法的类，JMH 会对该类中的基准测试方法进行测试。
• 迭代（Iteration）：JMH 会多次执行基准测试方法，每次执行称为一次迭代。通过多次迭代可以减少随机因素的影响，提高测试结果的准确性。
• 预热（Warmup）：在正式测试之前，JMH 会进行一定次数的预热迭代。预热的目的是让 JVM 有足够的时间进行 JIT 编译、类加载等操作，使代码运行在稳定的状态。
• 测量（Measurement）：在预热完成后，JMH 会进行正式的测量迭代，收集性能数据。
• 线程（Threads）：可以指定基准测试方法的执行线程数，用于测试多线程环境下的性能。
• 模式（Mode）：JMH 支持多种测试模式，如吞吐量（Throughput）、平均时间（AverageTime）等，用于不同的性能评估需求。

Java JMH 使用方法

引入依赖

首先，在项目中引入 JMH 的依赖。如果使用 Maven，可以在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-core</artifactId>
    <version>1.36</version>
</dependency>
<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-generator-annprocess</artifactId>
    <version>1.36</version>
    <scope>provided</scope>
</dependency>

编写基准测试类

以下是一个简单的 JMH 基准测试类示例：

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.TimeUnit;

public class JMHSample_01_HelloWorld {

    @Benchmark
    public void wellHelloThere() {
        // 模拟一些操作
        int a = 1 + 2;
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
               .include(JMHSample_01_HelloWorld.class.getSimpleName())
               .mode(Mode.Throughput)
               .timeUnit(TimeUnit.SECONDS)
               .warmupIterations(5)
               .measurementIterations(5)
               .forks(1)
               .build();

        new Runner(opt).run();
    }
}

代码解释

• @Benchmark 注解标记的 wellHelloThere 方法是基准测试方法。
• 在 main 方法中，通过 OptionsBuilder 配置测试选项，包括测试类、测试模式、时间单位、预热迭代次数、测量迭代次数和分叉数等。
• 最后，创建 Runner 对象并运行测试。

运行基准测试

可以直接运行 main 方法来执行基准测试。运行完成后，JMH 会输出详细的性能测试结果，包括吞吐量、平均时间等指标。

Java JMH 常见实践

测试不同数据结构的性能

以下是一个比较 ArrayList 和 LinkedList 在随机访问性能的示例：

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public class ListAccessBenchmark {

    private static final int SIZE = 1000;
    private static final List<Integer> arrayList = new ArrayList<>();
    private static final List<Integer> linkedList = new LinkedList<>();

    static {
        for (int i = 0; i < SIZE; i++) {
            arrayList.add(i);
            linkedList.add(i);
        }
    }

    @Benchmark
    public int arrayListRandomAccess() {
        return arrayList.get(SIZE / 2);
    }

    @Benchmark
    public int linkedListRandomAccess() {
        return linkedList.get(SIZE / 2);
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
               .include(ListAccessBenchmark.class.getSimpleName())
               .forks(1)
               .build();

        new Runner(opt).run();
    }
}

通过这个示例，可以直观地比较 ArrayList 和 LinkedList 在随机访问时的性能差异。

测试不同算法的性能

以下是一个比较冒泡排序和快速排序性能的示例：

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.Arrays;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public class SortingBenchmark {

    private static final int SIZE = 1000;
    private static final int[] array = new int[SIZE];

    static {
        for (int i = 0; i < SIZE; i++) {
            array[i] = (int) (Math.random() * SIZE);
        }
    }

    @Benchmark
    public int[] bubbleSort() {
        int[] arr = Arrays.copyOf(array, array.length);
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }

    @Benchmark
    public int[] quickSort() {
        int[] arr = Arrays.copyOf(array, array.length);
        quickSort(arr, 0, arr.length - 1);
        return arr;
    }

    private void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }

    private int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = (low - 1);
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
               .include(SortingBenchmark.class.getSimpleName())
               .forks(1)
               .build();

        new Runner(opt).run();
    }
}

通过这个示例，可以比较冒泡排序和快速排序在处理大规模数据时的性能差异。

Java JMH 最佳实践

避免死代码消除

在基准测试方法中，要确保代码的执行结果被使用，避免 JVM 进行死代码消除。例如：

@Benchmark
public int addNumbers() {
    int a = 1;
    int b = 2;
    int result = a + b;
    return result; // 确保结果被返回，避免死代码消除
}

合理设置预热和测量迭代次数

预热迭代次数要足够，让 JVM 达到稳定状态；测量迭代次数也要足够多，以减少随机因素的影响。一般来说，可以根据实际情况设置预热迭代次数为 5 - 10 次，测量迭代次数为 10 - 20 次。

选择合适的测试模式

根据测试需求选择合适的测试模式，如吞吐量模式适合评估系统的处理能力，平均时间模式适合评估单次操作的性能。

多线程测试

如果需要测试多线程环境下的性能，可以通过 @Threads 注解指定线程数。例如：

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Threads;

@Threads(4) // 指定 4 个线程执行基准测试方法
public class MultiThreadBenchmark {

    @Benchmark
    public void multiThreadTask() {
        // 多线程任务
    }
}

小结

Java JMH 是一个强大的基准测试工具，通过本文的介绍，我们了解了 JMH 的基础概念、使用方法、常见实践和最佳实践。在实际开发中，合理使用 JMH 可以帮助我们准确评估代码的性能，找出性能瓶颈，优化代码。同时，要注意遵循最佳实践，确保测试结果的准确性和可靠性。

参考资料

• Java Microbenchmark Harness (JMH) Documentation
• JMH Samples