使用JMH进行性能测试

文章目录

使用JMH进行性能测试
- 1.什么是JMH
- 2.JMH使用
- 3.JMH的基本概念和配置
- - 1.模式（Mode）
  - 2.迭代（Iteration）
  - 3.预热（Warmup）
  - 4.状态（State）
  - 5.配置类（Options/OptionsBuilder）
- 4.理解JMH中的Mode
- 5.理解JMH中的State

1.什么是JMH

JMH（Java Microbenchmark Harness） 是一个在OpenJDK项目中发布的，专门用于性能测试的框架，其精度可以达到毫秒级。通过JMH可以对对个方法的性能进行定量分析。比如，当要知道执行一个函数需要多少时间，或当对一个算法有多重不同实现时，需要选取性能最好的那个。

2.JMH使用

通过maven引入依赖

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

一个最简单的JMH程序如下：

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.concurrent.TimeUnit;/*** 初识JMH框架** @author : snail* @date : 2022-01-04 12:02**/@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public class JMHSample_01_HelloWorld {@Benchmarkpublic void wellHelloThere(){}public static void main(String[] args) throws RunnerException {Options opt = new OptionsBuilder().include(JMHSample_01_HelloWorld.class.getSimpleName()).forks(1).build();new Runner(opt).run();}
}

其中被度量的代码为函数wellHelloThere。类似于JUnit，被度量代码用注解@Benchmark标注，这里仅为一个空函数。

在main函数中，首先对测试用例进行配置，使用Builder模式配置测试，将配置参数存入Options对象，并使用Options对象构造Runner启动测试。

启动执行测试函数，输出如下：

# JMH version: 1.20
# VM version: JDK 1.8.0_221, VM 25.221-b11
# VM invoker: C:\Program Files\Java\jdk1.8.0_221\jre\bin\java.exe
# VM options: -javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2021.1\lib\idea_rt.jar=9766:C:\Program Files\JetBrains\IntelliJ IDEA 2021.1\bin -Dfile.encoding=UTF-8
# Warmup: 20 iterations, 1 s each
# Measurement: 20 iterations, 1 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: com.snail.test.jmh.JMHSample_01_HelloWorld.wellHelloThere# Run progress: 0.00% complete, ETA 00:00:40
# Fork: 1 of 1
# Warmup Iteration   1: ≈ 10⁻⁴ us/op
# Warmup Iteration   2: ≈ 10⁻⁴ us/op
# Warmup Iteration   3: ≈ 10⁻⁴ us/op
# Warmup Iteration   4: ≈ 10⁻⁴ us/op
# Warmup Iteration   5: ≈ 10⁻⁴ us/op
# Warmup Iteration   6: ≈ 10⁻⁴ us/op
# Warmup Iteration   7: ≈ 10⁻⁴ us/op
# Warmup Iteration   8: ≈ 10⁻⁴ us/op
# Warmup Iteration   9: ≈ 10⁻⁴ us/op
# Warmup Iteration  10: ≈ 10⁻⁴ us/op
# Warmup Iteration  11: ≈ 10⁻⁴ us/op
# Warmup Iteration  12: ≈ 10⁻⁴ us/op
# Warmup Iteration  13: ≈ 10⁻⁴ us/op
# Warmup Iteration  14: ≈ 10⁻⁴ us/op
# Warmup Iteration  15: ≈ 10⁻⁴ us/op
# Warmup Iteration  16: ≈ 10⁻⁴ us/op
# Warmup Iteration  17: ≈ 10⁻⁴ us/op
# Warmup Iteration  18: ≈ 10⁻⁴ us/op
# Warmup Iteration  19: ≈ 10⁻⁴ us/op
# Warmup Iteration  20: ≈ 10⁻⁴ us/op
Iteration   1: ≈ 10⁻⁴ us/op
Iteration   2: ≈ 10⁻⁴ us/op
Iteration   3: ≈ 10⁻⁴ us/op
Iteration   4: ≈ 10⁻⁴ us/op
Iteration   5: ≈ 10⁻⁴ us/op
Iteration   6: ≈ 10⁻⁴ us/op
Iteration   7: ≈ 10⁻⁴ us/op
Iteration   8: ≈ 10⁻⁴ us/op
Iteration   9: ≈ 10⁻⁴ us/op
Iteration  10: ≈ 10⁻⁴ us/op
Iteration  11: ≈ 10⁻⁴ us/op
Iteration  12: ≈ 10⁻⁴ us/op
Iteration  13: ≈ 10⁻⁴ us/op
Iteration  14: ≈ 10⁻⁴ us/op
Iteration  15: ≈ 10⁻⁴ us/op
Iteration  16: ≈ 10⁻⁴ us/op
Iteration  17: ≈ 10⁻⁴ us/op
Iteration  18: ≈ 10⁻⁴ us/op
Iteration  19: ≈ 10⁻⁴ us/op
Iteration  20: ≈ 10⁻⁴ us/opResult "com.snail.test.jmh.JMHSample_01_HelloWorld.wellHelloThere":≈ 10⁻⁴ us/op# Run complete. Total time: 00:00:41Benchmark                               Mode  Cnt   Score    Error  Units
JMHSample_01_HelloWorld.wellHelloThere  avgt   20  ≈ 10⁻⁴           us/opProcess finished with exit code 0

以上输出是一个测试结果的报告，第1-10行表示测试的基本信息。如使用的Java路径，预热代码的迭代次数，测量代码的迭代次数，使用的线程数量，测试的统计单位等。第14-33行显示了每一次热身中的性能指标，预热测试不会作为最终的统计结果。预热的目的是让Java虚拟机对被测试代码进行足够多的优化，比如，在预热后，被测试代码应该得到充分的JIT编译和优化。第34-53行开始显示测量迭代的情况，每一次迭代都显示了当前的执行速率，即一个操作所花费的时间。在进行了20次迭代后，进行统计，在本例中，第63行显示了wellHelloThere函数平均执行花费时间以及误差。

3.JMH的基本概念和配置

为了能更好的使用JMH的各项功能，首先需要对JMH的基本概念有所了解。

1.模式（Mode）

Mode表示JMH的测量方式和角度，共有四种。

Throughput：整体吞吐量，表示1秒内可以执行多少次调用。
AverageTime：调用的平均时间，指每一次调用所需要的时间。
SampleTime：随机取样，最后输出取样结果的分布，例如：“99%的调用在xxx毫秒以内，99.99%的调用在xxx毫秒以内”。
SingleShotTime：以上模式都是默认一次Iteration是1秒，唯有SingleShotTime只运行一次。旺旺同时把warmup次数设为0，用于测试冷启动时的性能。

2.迭代（Iteration）

迭代是JMH的一次测量单位。在大部分测量模式下，一次迭代表示1秒。在这疫苗内会不间断调用被测试方法，并采样计算吞吐量、平均时间等。

3.预热（Warmup）

由于Java虚拟机的JIT存在，同一个方法在JIT编译前后的时间将会不同。通常只考虑方法在JIT编译后的性能。

4.状态（State）

通过state可以指定一个对象的作用范围，范围主要有两种。一种为线程范围，也就是一个对象只会被一个线程访问。在多线程池测试时，会为每一个线程生成一个对象。另一种是基准测试范围（Benchmark），即多个线程共享一个实例。

5.配置类（Options/OptionsBuilder）

在测试开始前，首先要对测试进行配置。通常需要指定一些参数，比如指定测试类（include）、使用的进程个数（fork）、预热迭代次数（warmupIterations）。在配置启动测试时，需要使用配置类，如：

     Options opt = new OptionsBuilder().include(JMHSample_01_HelloWorld.class.getSimpleName()).forks(1).build();new Runner(opt).run();

4.理解JMH中的Mode

在JMH中，吞吐量和方法执行的平均时间是最常用的统计方式。如下是吞吐量的测量方法：

    @Benchmark@BenchmarkMode(Mode.Throughput)@OutputTimeUnit(TimeUnit.SECONDS)public void measureThroughput() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}

输出结果：

Benchmark                                   Mode  Cnt   Score    Error  Units
JMHSample_01_HelloWorld.measureThroughput  thrpt   20   9.045 ±  0.026  ops/s

统计方法的平均执行时间设置如下：

    @Benchmark@BenchmarkMode(Mode.AverageTime)@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureAvgTime() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}

输出结果：

Benchmark                               Mode  Cnt       Score     Error  Units
JMHSample_01_HelloWorld.measureAvgTime  avgt   20  110431.930 ± 444.557  us/op

上面的代码表示每个操作需要约100毫秒。

另一种统计方式是采样，即不再计算每个执行方法的平均执行时间，而是通过采样得到部分方法的执行时间，代码如下：

    @Benchmark@BenchmarkMode(Mode.SampleTime)@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureSamples() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}

输出结果：

Benchmark                                                        Mode  Cnt       Score     Error  Units
JMHSample_01_HelloWorld.measureSamples                         sample  200  110289.224 ± 286.771  us/op
JMHSample_01_HelloWorld.measureSamples:measureSamples·p0.00    sample       105775.104            us/op
JMHSample_01_HelloWorld.measureSamples:measureSamples·p0.50    sample       110624.768            us/op
JMHSample_01_HelloWorld.measureSamples:measureSamples·p0.90    sample       111673.344            us/op
JMHSample_01_HelloWorld.measureSamples:measureSamples·p0.95    sample       111673.344            us/op
JMHSample_01_HelloWorld.measureSamples:measureSamples·p0.99    sample       113362.862            us/op
JMHSample_01_HelloWorld.measureSamples:measureSamples·p0.999   sample       114294.784            us/op
JMHSample_01_HelloWorld.measureSamples:measureSamples·p0.9999  sample       114294.784            us/op
JMHSample_01_HelloWorld.measureSamples:measureSamples·p1.00    sample       114294.784            us/op

上面的结果表示，在采样到的方法中，平均的执行时间是110289μs。其中，有一半的调用在110624μs内完成，90%的调用在111673μs内完成，全部采样调用均在114294μs内完成。

5.理解JMH中的State

JMH中的State可以理解为变量或者数据模型的作用域，通常包括整个Benchmark级别和Thread线程级别。

声明两个数据模型，一个是Benchmark级别，另一个是Thread级别。

    @State(Scope.Benchmark)public static class BenchmarkState{volatile double x = Math.PI;}@State(Scope.Thread)public static class ThreadState{volatile double x = Math.PI;}

使用Benchmark方法对上述模型进行访问

    /*** 每个线程都有自己的数据复制* @param state*/@Benchmark@BenchmarkMode(Mode.Throughput)@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureUnshared(ThreadState state){state.x++;}/*** 所有测试线程共享一份数据* @param state*/@Benchmark@BenchmarkMode(Mode.Throughput)@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureShared(BenchmarkState state){state.x++;}

结果如下：

Benchmark                                 Mode  Cnt    Score   Error   Units
JMHSample_01_HelloWorld.measureShared    thrpt   20  154.666 ± 0.141  ops/us
JMHSample_01_HelloWorld.measureUnshared  thrpt   20  154.542 ± 0.309  ops/us

参考书籍：《实战 Java高并发程序设计（第二版）》