Java应用中的性能基准测试：JMH的高级使用与结果解读
大家好，今天我们来深入探讨Java性能基准测试框架JMH（Java Microbenchmark Harness）的高级使用方法以及如何解读其结果。JMH是OpenJDK官方提供的基准测试工具，能够帮助我们精确测量Java代码的性能，避免常见的性能陷阱。
1. JMH 的基本概念回顾
在深入高级特性之前，我们先简单回顾一下JMH的核心概念：
- Benchmark: 你需要测试的代码片段，通常是一个方法。
- State: Benchmark方法需要访问的数据。 State对象可以在不同线程之间共享，也可以是线程独有的。
- Scope: State对象的生命周期。常见Scope包括：
Scope.Thread: 每个线程拥有一个独立的State对象实例。Scope.Benchmark: 所有线程共享一个State对象实例。Scope.Group: 同一个组内的线程共享一个State对象实例。
- Mode: JMH的测量模式，定义了如何衡量benchmark的性能。常见的Mode包括：
Mode.Throughput: 衡量吞吐量，即单位时间内执行benchmark的次数。Mode.AverageTime: 衡量平均执行时间。Mode.SampleTime: 对benchmark的执行时间进行采样，提供更详细的统计信息。Mode.SingleShotTime: 只执行一次benchmark，通常用于冷启动分析。Mode.All: 执行所有测量模式。
- Warmup: 在正式测量之前，先预热benchmark，使JVM完成代码编译和优化。
- Measurement: 正式测量benchmark的阶段。
- Fork: JMH会fork一个新的JVM进程来运行每个benchmark，避免benchmark之间的相互影响。
- Annotation: JMH使用注解来配置benchmark的行为，例如
@Benchmark,@State,@Setup,@TearDown等。
2. 高级用法一：使用Parametrized Benchmark
有时候，我们需要测试一个方法在不同参数下的性能表现。JMH提供了@Param注解来实现参数化Benchmark。
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 ParametrizedBenchmark {
@Param({"10", "100", "1000"})
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 < size; i++) {
data[i] = random.nextInt();
}
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public void measureSum(Blackhole bh) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += data[i];
}
bh.consume(sum); // 防止JIT优化掉无用的计算
}
public static void main(String[] args) throws RunnerException {
Options opt = new OptionsBuilder()
.include(ParametrizedBenchmark.class.getSimpleName())
.forks(1)
.warmupIterations(5)
.measurementIterations(5)
.build();
new Runner(opt).run();
}
}在这个例子中，size参数使用@Param注解指定了三个不同的值：10, 100, 1000。JMH会分别使用这三个值运行measureSum方法，并输出对应的性能结果。 @Setup(Level.Trial) 注解保证了每次测试不同大小的数组时，都会重新生成数据，避免上一次测试的影响。Blackhole用于防止JIT编译器优化掉无用的计算。
3. 高级用法二：使用State的Group Scope
当需要在多个线程之间共享State，但又不希望所有线程都共享同一个State实例时，可以使用Scope.Group。这在模拟多线程环境下的数据共享和竞争时非常有用。
import org.openjdk.jmh.annotations.*;
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;
import java.util.concurrent.atomic.AtomicInteger;
@State(Scope.Group)
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
public class GroupScopeBenchmark {
private AtomicInteger counter = new AtomicInteger(0);
@Benchmark
@Group("g")
@GroupThreads(3)
public void increment() {
counter.incrementAndGet();
}
@Benchmark
@Group("g")
@GroupThreads(1)
public int get() {
return counter.get();
}
public static void main(String[] args) throws RunnerException {
Options opt = new OptionsBuilder()
.include(GroupScopeBenchmark.class.getSimpleName())
.build();
new Runner(opt).run();
}
}在这个例子中，counter是一个AtomicInteger，使用Scope.Group注解。increment方法和get方法属于同一个组 "g"。increment方法有3个线程执行，get方法有1个线程执行。因此，这模拟了3个线程并发增加计数器，1个线程读取计数器的场景。 @GroupThreads 指定了每个组内方法使用的线程数。 JMH 会创建多个组实例，每个组实例内的线程共享同一个 counter 对象。
4. 高级用法三：使用自定义的Result类型
JMH默认情况下会输出吞吐量、平均时间等指标。但是，有时候我们需要自定义一些指标，例如错误率、成功率等。JMH允许我们自定义Result类型，并输出这些自定义的指标。
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.results.Aggregation;
import org.openjdk.jmh.results.Result;
import org.openjdk.jmh.results.ResultRole;
import org.openjdk.jmh.results.ScalarResult;
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)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
public class CustomResultBenchmark {
private Random random = new Random();
@Benchmark
public CustomResult measure() {
int value = random.nextInt(100);
boolean success = value > 50;
return new CustomResult(success);
}
public static class CustomResult extends Result<CustomResult> {
private final boolean success;
public CustomResult(boolean success) {
this.success = success;
}
@Override
public ResultRole getRole() {
return ResultRole.SECONDARY; // 表示这是一个辅助结果
}
@Override
public Number getValue() {
return success ? 1 : 0; // 返回成功或失败的数值
}
@Override
public String getLabel() {
return "Success"; // 结果的标签
}
@Override
public String getUnit() {
return "boolean"; // 结果的单位
}
@Override
public int compareTo(CustomResult o) {
return Boolean.compare(this.success, o.success);
}
@Override
public void add(CustomResult r) {
// This method is not used in this example, but it's required by the interface.
// You can implement it if you need to aggregate results from multiple runs.
}
}
public static void main(String[] args) throws RunnerException {
Options opt = new OptionsBuilder()
.include(CustomResultBenchmark.class.getSimpleName())
.build();
new Runner(opt).run();
}
}在这个例子中，CustomResult 类继承自 Result 类，并实现了 getValue, getLabel, getUnit 等方法，用于定义自定义结果的数值、标签和单位。 getRole() 方法返回 ResultRole.SECONDARY，表示这是一个辅助结果，不会影响主要的性能指标。 JMH 会输出一个名为 "Success" 的结果，其值为 0 或 1，表示 benchmark 是否成功。
5. 高级用法四：使用CompilerControl注解
@CompilerControl 注解可以控制JVM编译器的行为，例如强制内联、禁止内联等。这在分析特定代码片段的编译优化效果时非常有用。
import org.openjdk.jmh.annotations.*;
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 org.openjdk.jmh.infra.Blackhole;
import java.util.concurrent.TimeUnit;
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
public class CompilerControlBenchmark {
private int a = 1;
private int b = 2;
@CompilerControl(CompilerControl.Mode.INLINE) // 强制内联
private int addInline(int x, int y) {
return x + y;
}
@CompilerControl(CompilerControl.Mode.DONT_INLINE) // 禁止内联
private int addNoInline(int x, int y) {
return x + y;
}
@Benchmark
public void measureInline(Blackhole bh) {
bh.consume(addInline(a, b));
}
@Benchmark
public void measureNoInline(Blackhole bh) {
bh.consume(addNoInline(a, b));
}
public static void main(String[] args) throws RunnerException {
Options opt = new OptionsBuilder()
.include(CompilerControlBenchmark.class.getSimpleName())
.build();
new Runner(opt).run();
}
}在这个例子中，addInline 方法被强制内联，addNoInline 方法被禁止内联。通过比较 measureInline 和 measureNoInline 的性能，可以了解内联对性能的影响。
6. JMH 结果解读
JMH的输出结果包含了大量的统计信息，理解这些信息对于分析性能问题至关重要。
- Score: Benchmark的主要性能指标，例如吞吐量或平均时间。
- Error: Score的标准误差，表示测量结果的精度。
- Units: Score的单位。
- Warmup Iterations: 预热迭代的次数。
- Measurement Iterations: 正式测量迭代的次数。
- Fork: JMH fork的JVM进程数。
- Confidence Interval: 置信区间，表示真实值落在该区间的概率。
- Percentiles: 百分位数，例如50th percentile表示有一半的执行时间小于该值。
- Histogram: 直方图，用于可视化执行时间的分布。
关键点：
- 关注Error: 标准误差越小，测量结果越精确。
- 理解Percentiles: 百分位数可以帮助你了解执行时间的分布，例如是否存在长尾效应。
- 分析Histogram: 直方图可以更直观地展示执行时间的分布情况。
- 多次运行: 为了获得更可靠的结果，建议多次运行benchmark。
- 控制变量: 确保测试环境的稳定，避免其他因素干扰测量结果。
举例说明：
假设JMH输出以下结果：
Benchmark Mode Cnt Score Error Units
MyBenchmark.myMethod thrpt 5 12345.678 ± 123.456 ops/ms这表示MyBenchmark.myMethod的吞吐量为12345.678 ops/ms，标准误差为123.456 ops/ms。这意味着在99.9%的置信度下，真实的吞吐量可能在 12345.678 ± 3 * 123.456 ops/ms 之间。
7. 避免常见的JMH使用陷阱
在使用JMH时，需要注意一些常见的陷阱，以确保测量结果的准确性。
- Dead Code Elimination: JIT编译器可能会优化掉无用的代码，导致测量结果不准确。可以使用
Blackhole来防止这种情况。 - False Sharing: 当多个线程访问同一个缓存行中的不同变量时，会导致缓存失效，降低性能。可以使用
@Contended注解来避免False Sharing。 - Insufficient Warmup: 如果预热时间不足，JIT编译器可能没有完成代码编译和优化，导致测量结果不准确。
- Inaccurate Clock: 在高并发场景下，系统时钟可能不够精确，影响测量结果。可以使用
org.openjdk.jmh.util.NanoClock来获取更精确的时间。 - Garbage Collection: GC可能会影响测量结果，可以使用不同的GC算法进行测试，并分析GC日志。
8. 实战案例：优化字符串拼接
我们来看一个实际的例子，如何使用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)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
public class StringConcatBenchmark {
private String[] data;
@Param({"10", "100", "1000"})
public int size;
@Setup(Level.Trial)
public void setup() {
data = new String[size];
Random random = new Random();
for (int i = 0; i < size; i++) {
data[i] = String.valueOf(random.nextInt());
}
}
@Benchmark
public void concat(Blackhole bh) {
String result = "";
for (int i = 0; i < size; i++) {
result += data[i]; // 使用 + 运算符拼接字符串
}
bh.consume(result);
}
@Benchmark
public void stringBuilder(Blackhole bh) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < size; i++) {
sb.append(data[i]); // 使用 StringBuilder 拼接字符串
}
bh.consume(sb.toString());
}
public static void main(String[] args) throws RunnerException {
Options opt = new OptionsBuilder()
.include(StringConcatBenchmark.class.getSimpleName())
.build();
new Runner(opt).run();
}
}这个例子比较了使用 + 运算符和 StringBuilder 拼接字符串的性能。运行结果会显示 StringBuilder 的性能明显优于 + 运算符，尤其是在字符串数量较多时。这是因为 + 运算符每次拼接都会创建一个新的字符串对象，而 StringBuilder 则是在原对象上进行修改，避免了大量的对象创建和销毁。
最终结果：
通过今天的分享，我们学习了JMH的高级用法，包括参数化Benchmark、Group Scope、自定义Result类型和CompilerControl注解。同时，我们也了解了如何解读JMH的输出结果，以及如何避免常见的JMH使用陷阱。希望这些知识能够帮助大家更好地进行Java性能基准测试，并优化自己的代码。
总结与回顾：
- JMH提供了丰富的功能来满足各种基准测试需求。
- 理解JMH的输出结果对于分析性能问题至关重要。
- 避免常见的JMH使用陷阱，确保测量结果的准确性。
- JMH是优化Java代码性能的强大工具。