使用JMH进行性能测试

最新推荐文章于 2025-02-26 16:04:31 发布

蜗牛小传

最新推荐文章于 2025-02-26 16:04:31 发布

阅读量1.3k

点赞数 1

分类专栏： java 文章标签： java 后端

本文链接：https://blog.youkuaiyun.com/zhen4xi4fei/article/details/122306252

版权

java 专栏收录该内容

7 篇文章

订阅专栏

使用JMH进行性能测试

文章目录

使用JMH进行性能测试

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 {
    @Benchmark
    public 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/op


Result "com.snail.test.jmh.JMHSample_01_HelloWorld.wellHelloThere":
  ≈ 10⁻⁴ us/op


# Run complete. Total time: 00:00:41

Benchmark                               Mode  Cnt   Score    Error  Units
JMHSample_01_HelloWorld.wellHelloThere  avgt   20  ≈ 10⁻⁴           us/op

Process 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