使用JMH进行Java代码的微基准测试：消除环境干扰与统计偏差

使用JMH进行Java代码的微基准测试：消除环境干扰与统计偏差

大家好！今天我们来深入探讨一个对于Java开发者至关重要的话题：如何使用JMH（Java Microbenchmark Harness）进行Java代码的微基准测试，并有效地消除环境干扰和统计偏差，确保测试结果的准确性和可靠性。

在软件开发过程中，性能优化是不可或缺的一环。我们需要了解代码在各种场景下的性能表现，找出瓶颈并进行改进。而微基准测试则专注于对代码片段进行精确的性能测量，例如一个方法、一个循环，甚至一行代码。但要得到有意义的微基准测试结果并非易事，环境干扰和统计偏差是两大挑战。JMH正是为了解决这些问题而生的。

1. 为什么需要JMH？传统方法的问题

在没有专门的基准测试工具之前，开发者通常会使用简单的时间测量方法，例如：

long startTime = System.nanoTime();
// 要测试的代码
long endTime = System.nanoTime();
long duration = endTime - startTime;
System.out.println("代码执行时间：" + duration + "纳秒");

这种方法看似简单直接，但存在诸多问题：

• JVM预热问题： JVM的即时编译器（JIT）会将热点代码编译成机器码，从而显著提升性能。首次执行的代码往往性能较差，后续执行会逐渐优化。简单的计时方法无法准确反映稳定状态下的性能。
• 垃圾回收干扰： 垃圾回收（GC）会暂停应用程序的执行，影响计时的准确性。
• CPU时钟频率变化： 现代CPU具有动态调整时钟频率的能力，这也会影响计时的准确性。
• 死代码消除： 如果编译器认为某些代码对程序的结果没有影响，可能会将其优化掉，导致测试结果不准确。
• 统计偏差： 单次测量的结果可能受到随机因素的影响，缺乏统计意义。

JMH通过一系列机制来解决这些问题，提供更可靠的微基准测试环境。

2. JMH入门：基本概念和使用方法

JMH是一个由OpenJDK维护的基准测试工具，它提供了一套完整的框架，用于编写、运行和分析Java代码的微基准测试。

2.1 添加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>

2.2 创建第一个JMH基准测试

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

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
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.Random;
import java.util.concurrent.TimeUnit;

@State(Scope.Thread)
public class MyBenchmark {

    private int[] data;
    private Random random = new Random();

    @Setup(Level.Trial)
    public void setup() {
        data = new int[1000];
        for (int i = 0; i < data.length; i++) {
            data[i] = random.nextInt();
        }
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public void measureSum(Blackhole blackhole) {
        int sum = 0;
        for (int value : data) {
            sum += value;
        }
        blackhole.consume(sum); // 防止死代码消除
    }

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

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

代码解释：

• @State(Scope.Thread): 声明一个状态对象，Scope.Thread表示每个线程拥有一个状态对象实例。这避免了多线程并发测试时的数据竞争。其他Scope还有Scope.Benchmark (每个基准测试方法一个实例) 和 Scope.Group (每个线程组一个实例)。
• @Setup(Level.Trial): 在每个Trial (一次完整的基准测试运行) 开始前执行，用于初始化测试数据。Level.Trial表示在整个测试过程执行一次。其他Level还有 Level.Iteration (每次迭代执行) 和 Level.Invocation (每次方法调用执行)。
• @Benchmark: 标记一个方法为基准测试方法。
• @BenchmarkMode(Mode.AverageTime): 指定基准测试的模式为平均时间。其他模式包括 Mode.Throughput (吞吐量), Mode.SampleTime (采样时间), Mode.SingleShotTime (单次时间) 和 Mode.All (所有模式)。
• @OutputTimeUnit(TimeUnit.NANOSECONDS): 指定输出的时间单位为纳秒。
• Blackhole: JMH提供的一个工具类，用于防止死代码消除。blackhole.consume(sum) 会强制使用sum变量，防止编译器将其优化掉。
• OptionsBuilder: 用于配置JMH的运行参数，例如要运行的基准测试类、forks数量、预热迭代次数和测量迭代次数。
• forks(1): 指定forks的数量为1。JMH会fork一个新的JVM进程来运行基准测试，以隔离环境干扰。
• warmupIterations(5): 指定预热迭代的次数为5。JMH会先运行几次基准测试方法，让JVM进行预热，然后再进行正式的测量。
• measurementIterations(5): 指定测量迭代的次数为5。JMH会运行多次基准测试方法，并计算平均值、标准差等统计信息。

2.3 运行JMH基准测试

编译并运行包含main方法的类即可启动JMH基准测试。JMH会生成详细的报告，包含平均执行时间、标准差、吞吐量等信息。

2.4 JMH 报告解读

JMH生成的报告通常包含以下信息：

• Benchmark: 基准测试方法的名称。
• Mode: 基准测试的模式（例如 AverageTime）。
• Threads: 运行基准测试的线程数。
• Samples: 采集的样本数量。
• Score: 基准测试的得分，通常是平均执行时间或吞吐量。
• Score Error (99.9%): 置信区间，表示得分的误差范围。
• Unit: 得分的单位（例如 ns/op）。

3. 消除环境干扰的关键技术

要获得可靠的基准测试结果，必须尽可能消除环境干扰。JMH提供了一系列技术来应对这些问题：

3.1 JVM预热（Warmup）

JVM的JIT编译器需要时间来优化代码。如果没有充分的预热，首次执行的代码性能会较低，导致测试结果不准确。JMH通过@Warmup注解或warmupIterations参数来指定预热迭代的次数。

@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) // 预热5次，每次1秒
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) // 测量5次，每次1秒
@Benchmark
public void measureSum(Blackhole blackhole) {
    // ...
}

3.2 分叉（Forking）

JMH会fork一个新的JVM进程来运行基准测试，以隔离环境干扰。每个fork都拥有独立的JVM实例，避免了不同基准测试之间的相互影响。通过forks参数可以指定fork的数量。

Options opt = new OptionsBuilder()
    .include(MyBenchmark.class.getSimpleName())
    .forks(3) // Fork 3个JVM进程
    .warmupIterations(5)
    .measurementIterations(5)
    .build();

3.3 死代码消除（Dead Code Elimination）

编译器可能会优化掉一些对程序结果没有影响的代码，导致测试结果不准确。JMH提供了Blackhole类来防止死代码消除。Blackhole.consume()方法会强制使用变量，防止编译器将其优化掉。

@Benchmark
public void measureSum(Blackhole blackhole) {
    int sum = 0;
    for (int value : data) {
        sum += value;
    }
    blackhole.consume(sum); // 防止死代码消除
}

3.4 垃圾回收（Garbage Collection）

垃圾回收会暂停应用程序的执行，影响计时的准确性。JMH提供了一些选项来控制垃圾回收的行为。

• @CompilerControl(CompilerControl.Mode.INLINE): 强制内联基准测试方法，减少方法调用的开销，但也可能影响垃圾回收的行为。
• @Fork(jvmArgsAppend = "-XX:+DisableExplicitGC"): 禁用显式垃圾回收，防止在基准测试过程中手动触发垃圾回收。

3.5 CPU亲和性（CPU Affinity）

在多核CPU上，线程可能会在不同的核心之间迁移，影响性能。JMH提供了一些选项来控制线程的CPU亲和性，将线程绑定到特定的核心上。

• @GroupThreads: 将多个线程分配到同一个线程组，可以提高线程之间的协作效率。
• 需要借助操作系统工具，例如 taskset (Linux) 或 affinity (Windows) 来设置CPU亲和性。

3.6 代码位置（Code Placement）

代码在内存中的位置也会影响性能。JMH提供了一些选项来控制代码的位置，例如使用@HotSpotIntrinsicCandidate注解来强制内联方法。

4. 避免统计偏差的策略

除了环境干扰，统计偏差也是影响基准测试结果准确性的一个重要因素。JMH提供了一些策略来避免统计偏差：

4.1 多次迭代和统计分析

JMH会运行多次基准测试方法，并计算平均值、标准差、置信区间等统计信息。这可以减少随机因素的影响，提高测试结果的可靠性。

@Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS) // 测量10次，每次1秒
@Benchmark
public void measureSum(Blackhole blackhole) {
    // ...
}

4.2 合理选择基准测试模式

JMH提供了多种基准测试模式，例如平均时间（AverageTime）、吞吐量（Throughput）、采样时间（SampleTime）等。选择合适的基准测试模式可以更准确地反映代码的性能。

• AverageTime: 测量代码的平均执行时间。适用于评估单个操作的性能。
• Throughput: 测量代码的吞吐量，即每单位时间执行的操作数量。适用于评估系统的整体性能。
• SampleTime: 采样代码的执行时间，可以获得更详细的性能分布信息。
• SingleShotTime: 只运行一次基准测试方法，适用于测量冷启动的性能。
• All: 运行所有基准测试模式。

4.3 控制变量

在进行基准测试时，要尽可能控制变量，确保每次测试的条件一致。例如，要测试不同数据结构的性能，应该使用相同的数据量和数据类型。

4.4 注意伪共享（False Sharing）

在多线程环境中，如果多个线程访问同一个缓存行的不同变量，可能会导致伪共享，降低性能。可以通过填充缓存行来避免伪共享。

@State(Scope.Thread)
public class FalseSharing {
    public static final int ITERATIONS = 100000000;

    public static class VolatileLong {
        public volatile long value = 0L;
        public long p1, p2, p3, p4, p5, p6; // 填充缓存行
    }

    public VolatileLong[] longs = new VolatileLong[2];

    @Setup(Level.Trial)
    public void setup() {
        longs[0] = new VolatileLong();
        longs[1] = new VolatileLong();
    }

    @Benchmark
    @Group("falseSharing")
    @GroupThreads(1)
    public void incrementLong0() {
        for (int i = 0; i < ITERATIONS; i++) {
            longs[0].value++;
        }
    }

    @Benchmark
    @Group("falseSharing")
    @GroupThreads(1)
    public void incrementLong1() {
        for (int i = 0; i < ITERATIONS; i++) {
            longs[1].value++;
        }
    }

    // ...
}

在这个例子中，VolatileLong类填充了缓存行，避免了longs[0]和longs[1]位于同一个缓存行中，从而避免了伪共享。

5. 高级用法：参数化测试、自定义结果处理

除了基本用法，JMH还提供了一些高级功能，可以更灵活地进行基准测试。

5.1 参数化测试

可以使用@Param注解来参数化基准测试方法，方便测试不同参数下的性能。

@State(Scope.Thread)
public class ParamBenchmark {

    @Param({"100", "1000", "10000"})
    public int size;

    private int[] data;

    @Setup(Level.Trial)
    public void setup() {
        data = new int[size];
        Random random = new Random();
        for (int i = 0; i < data.length; i++) {
            data[i] = random.nextInt();
        }
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public void measureSum(Blackhole blackhole) {
        int sum = 0;
        for (int value : data) {
            sum += value;
        }
        blackhole.consume(sum);
    }

    // ...
}

在这个例子中，size参数会被设置为100、1000和10000，JMH会分别运行基准测试方法，并生成不同的结果。

5.2 自定义结果处理

可以使用@ResultFormat注解来指定结果的格式，例如JSON、CSV等。也可以使用@OutputTimeUnit注解来指定输出的时间单位。

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@ResultFormat(ResultFormatType.JSON)
public void measureSum(Blackhole blackhole) {
    // ...
}

5.3 自定义状态

可以使用@State注解来创建自定义状态对象，并在基准测试方法中使用。这可以方便地管理测试数据和配置。

@State(Scope.Thread)
public class MyState {
    public int value;

    @Setup(Level.Invocation)
    public void setup() {
        value = new Random().nextInt();
    }
}

@Benchmark
public void measureValue(MyState state, Blackhole blackhole) {
    blackhole.consume(state.value);
}

5.4 Events 和 Listeners

JMH 允许注册事件监听器，在基准测试的不同阶段执行自定义逻辑。这可以用于收集额外的性能数据、进行日志记录或执行其他操作。可以通过实现 org.openjdk.jmh.runner.event.BenchmarkEventListener 接口来创建自定义监听器。

6. 常见问题和最佳实践

• 避免过度优化： 不要只关注微基准测试的结果，要结合实际应用场景进行综合评估。
• 使用真实数据： 尽可能使用真实数据进行基准测试，以更准确地反映代码的性能。
• 选择合适的基准测试工具： JMH适用于微基准测试，对于更复杂的性能测试，可能需要使用其他工具，例如JMeter、Gatling等。
• 分析结果： 要仔细分析JMH生成的报告，找出性能瓶颈并进行改进。
• 持续集成： 可以将JMH集成到持续集成流程中，定期运行基准测试，及时发现性能问题。

7. JMH测试配置参数表格

参数/注解	描述	默认值
@BenchmarkMode	指定基准测试的模式，如 AverageTime, Throughput, SampleTime, SingleShotTime, All.	AverageTime
@OutputTimeUnit	指定输出的时间单位，如 NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS.	NANOSECONDS
@State	定义一个状态对象，可以设置不同的作用域，如 Scope.Thread, Scope.Benchmark, Scope.Group.	无
@Setup	在基准测试开始前执行，用于初始化状态对象，可以设置不同的级别，如 Level.Trial, Level.Iteration, Level.Invocation.	无
@TearDown	在基准测试结束后执行，用于清理状态对象，可以设置不同的级别，如 Level.Trial, Level.Iteration, Level.Invocation.	无
@Param	用于参数化基准测试方法，可以指定多个参数值。	无
@Warmup	配置预热参数，包括预热迭代次数、时间和时间单位。	iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS
@Measurement	配置测量参数，包括测量迭代次数、时间和时间单位。	iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS
@Fork	配置fork参数，指定fork的数量，以及JVM参数。	forks = 1
@Threads	指定运行基准测试的线程数。	1
@Group	将多个基准测试方法分组，可以用于测试多线程并发场景。	无
@GroupThreads	指定每个线程组的线程数。	1
@CompilerControl	控制编译器的行为，如强制内联或禁用内联。	无
Blackhole	用于防止死代码消除，强制使用变量。	无

8. JMH实战案例：比较不同排序算法的性能

下面是一个使用JMH比较不同排序算法性能的实战案例：

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
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.Random;
import java.util.concurrent.TimeUnit;

@State(Scope.Thread)
public class SortBenchmark {

    private int[] data;
    private int[] dataToSort;
    private Random random = new Random();

    @Param({"100", "1000", "10000"})
    public int size;

    @Setup(Level.Trial)
    public void setup() {
        data = new int[size];
        for (int i = 0; i < data.length; i++) {
            data[i] = random.nextInt();
        }
    }

    @Setup(Level.Invocation)
    public void setupInvocation() {
        dataToSort = Arrays.copyOf(data, data.length); // 每次迭代都复制一份数据
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public void measureArraysSort(Blackhole blackhole) {
        Arrays.sort(dataToSort);
        blackhole.consume(dataToSort);
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public void measureBubbleSort(Blackhole blackhole) {
        bubbleSort(dataToSort);
        blackhole.consume(dataToSort);
    }

    private void bubbleSort(int[] arr) {
        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;
                }
            }
        }
    }

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

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

这个例子比较了Arrays.sort()方法和冒泡排序算法的性能。通过运行这个基准测试，可以清楚地看到Arrays.sort()方法在性能上远优于冒泡排序算法。

消除干扰，统计分析，JMH助力代码优化

JMH是Java微基准测试的利器，它通过一系列机制消除环境干扰和统计偏差，提供可靠的性能数据。合理使用JMH，可以帮助开发者找出代码瓶颈，进行有效优化，提升应用程序的性能。希望今天的分享能帮助大家更好地掌握JMH的使用，提升代码质量。