使用JMH编写基准测试

迷南。 2022-10-12 00:47 208阅读 0赞

### JMH 简介 ###

if 快还是 switch 快？HashMap 的初始化 size 要不要指定，指定之后性能可以提高多少？各种序列化方法哪个耗时更短？

无论出自何种原因需要进行性能评估，量化指标总是必要的。在大部分场合，简单地回答谁快谁慢是远远不够的，如何将程序性能量化呢？这就需要我们的主角 JMH 登场了！

JMH(Java Microbenchmark Harness)是用于代码微基准测试的工具套件，主要是基于方法层面的基准测试，精度可以达到纳秒级。该工具是由 Oracle 内部实现 JIT 的大牛们编写的，他们应该比任何人都了解 JIT 以及 JVM 对于基准测试的影响。

当你定位到热点方法，希望进一步优化方法性能的时候，就可以使用 JMH 对优化的结果进行量化的分析。JMH 比较典型的应用场景如下：

*  想准确地知道某个方法需要执行多长时间，以及执行时间和输入之间的相关性
 *  对比接口不同实现在给定条件下的吞吐量
 *  查看多少百分比的请求在多长时间内完成

详细文档和示例参考文档： [http://openjdk.java.net/projects/code-tools/jmh/][http_openjdk.java.net_projects_code-tools_jmh]

JMH是OpenJDK开发的，在JDK9中加入了JMH，之前版本需要通过如下方式引入：（目前 JMH 的最新版本为 1.23）：

<dependency>
        <groupId>org.openjdk.jmh</groupId>
        <artifactId>jmh-core</artifactId>
        <version>1.23</version>
    </dependency>
    
    <dependency>
        <groupId>org.openjdk.jmh</groupId>
        <artifactId>jmh-generator-annprocess</artifactId>
        <version>1.23</version>
    </dependency>

**1、Benchmark测试用例的编写和执行**

1）示例1:

这里写了两个@Benchmark，反序列化同一个常量JSON字符串到两个不同的Class，一个用LocalDateTime接收时间戳，另一个用Date接收，用的是业界最成熟的JSON库Jackson。

package cn.edu.nuc.Test;
    
    import com.fasterxml.jackson.core.JsonParseException;
    import com.fasterxml.jackson.databind.JavaType;
    import com.fasterxml.jackson.databind.JsonMappingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.SerializationFeature;
    import lombok.Data;
    import org.openjdk.jmh.annotations.*;
    import org.openjdk.jmh.infra.Blackhole;
    import org.openjdk.jmh.results.format.ResultFormatType;
    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.io.IOException;
    import java.time.LocalDateTime;
    import java.util.*;
    import java.util.concurrent.TimeUnit;
    
    @BenchmarkMode({Mode.Throughput})
    @OutputTimeUnit(TimeUnit.SECONDS)
    @Warmup(iterations = 1)
    @Measurement(iterations = 2)
    @Threads(1)
    @Fork(1)
    @State(Scope.Thread)
    public class Jackson2UtilBenchmark {
        private static String raw = "[{\"id\":1,\"name\":\"name1\",\"data\":[\"a\",\"b\",\"c\"]," +
                "\"createTime\":\"2019-05-09T01:53:13.396Z\",\"modifyTime\":\"2019-05-10T01:53:13.396Z\"}," +
                "{\"id\":2,\"name\":\"name2\",\"data\":[\"d\",\"e\",\"f\"],\"createTime\":\"2019-05-01T01:53:13.396Z\"," +
                "\"modifyTime\":\"2019-05-02T01:53:13.396Z\"}]";
    
        private ObjectMapper objectMapper = new ObjectMapper();
    
        private JavaType javaType = objectMapper.getTypeFactory().constructParametricType(ArrayList.class, SimplePojo.class);
        private JavaType javaTypeDate = objectMapper.getTypeFactory().constructParametricType(ArrayList.class, SimplePojoDate.class);
    
        @Setup(Level.Trial)
        public void setup() {
            objectMapper.findAndRegisterModules();
            objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        }
    
        @Benchmark
        public void parseLocalDateTime(Blackhole bh) throws IOException {
            bh.consume(objectMapper.readValue(raw, javaType));
        }
    
        @Benchmark
        public void parseDate(Blackhole bh) throws IOException {
            bh.consume(objectMapper.readValue(raw, javaTypeDate));
        }
        
    
        public static void main(String[] args) throws RunnerException {
            Options options = new OptionsBuilder()
                    .include(Jackson2UtilBenchmark.class.getSimpleName())
                    .result("result1.json")
                    .resultFormat(ResultFormatType.JSON)
                    .build();
            new Runner(options).run();
            
        }
    }
    
    @Data
    class SimplePojo {
        private Integer id;
        private String name;
        private List<String> data;
        private LocalDateTime createTime;
        private LocalDateTime modifyTime;
    }
    
    @Data
    class SimplePojoDate {
        private Integer id;
        private String name;
        private List<String> data;
        private Date createTime;
        private Date modifyTime;
    }

**注**：运行上面代码前，需要使用mvn package，这样会在traget/下生成META-INF/BenchmarkList，否则会包如下错误；此外，代码必须要有包名，否则mvn package的时候会提示报错。

![20210701220650172.png][]

**注**：jackson的版本需要是2.9.9，Java8增加了一套全新的日期时间类，Jackson对此也有支持。

2）示例2:字符串拼接的示例

package cn.edu.nuc.Test;
    import java.util.concurrent.TimeUnit;
    
    import org.openjdk.jmh.annotations.*;
    import org.openjdk.jmh.infra.Blackhole;
    import org.openjdk.jmh.results.format.ResultFormatType;
    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;
    
    @BenchmarkMode(Mode.AverageTime)
    @Warmup(iterations = 3, time = 1)
    @Measurement(iterations = 5, time = 5)
    @Threads(4)
    @Fork(1)
    @State(value = Scope.Benchmark)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public class StringConnectBenchmark {
        @Param(value = {"10", "50", "100"})
        private int length;
    
        @Benchmark
        public void testStringAdd(Blackhole blackhole) {
            String a = "";
            for (int i = 0; i < length; i++) {
                a += i;
            }
            blackhole.consume(a);
        }
    
        @Benchmark
        public void testStringBuilderAdd(Blackhole blackhole) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < length; i++) {
                sb.append(i);
            }
            blackhole.consume(sb.toString());
        }
    
        public static void main(String[] args) throws RunnerException {
            Options opt = new OptionsBuilder()
                    .include(StringConnectBenchmark.class.getSimpleName())
                    .result("result.json")
                    .resultFormat(ResultFormatType.JSON).build();
            new Runner(opt).run();
        }
    }

说明：这里使用了@Param注解来轮换不同的参数

### Benchmakr使用说明 ###

**1、常用注解**

@Benchmark：每个带Benchmark注解的都是一个微基准测试用例

@BenchmarkMode：吞吐量或者平均时间等等，配合@OutputTimeUnit作为计量指标，该注解可以是一个数组，例如@BenchmarkMode(\{Mode.SampleTime, Mode.AverageTime\})，value可取：

*  Throughput：整体吞吐量，每秒执行了多少次调用，单位为 ops/time
 *  AverageTime：用的平均时间，每次操作的平均时间，单位为 time/op
 *  SampleTime：随机取样，最后输出取样结果的分布
 *  SingleShotTime：只运行一次，往往同时把 Warmup 次数设为 0，用于测试冷启动时的性能
 *  All：上面的所有模式都执行一次

@Fork：每个测试Fork进程执行，指定Fork的数量，这是为了防止JVM PGO（Profile-Guided Optimization）影响测试结果

@Threads：每个基准测试启动的并发线程数量

@State：通过 State 可以指定一个对象的作用范围，JMH 根据 scope 来进行实例化和共享操作。@State 可以被继承使用，如果父类定义了该注解，子类则无需定义。由于 JMH 允许多线程同时执行测试，不同的选项含义如下：

*  Thread表示变量只在同一个线程同步，一般用Thread，用到的成员变量相当于是ThreadLocal的
 *  Benchmark表示变量整个测试的进程同步，比如方法A用到了变量B，线程C和线程D访问B是同一个变量需要加锁，而不是ThreadLocal的
 *  Group则是同一组的测试使用同样的变量，配合@Group @GroupThreads 给关联的测试分组和同步使用

@Warmup @Measurement：预热和正式开始的轮数，每次迭代时间和循环次数都在这里配置，value可取

*  iterations：预热的次数
 *  time：每次预热的时间
 *  timeUnit：时间的单位，默认秒
 *  batchSize：批处理大小，每次操作调用几次方法

@Setup @TearDown：这俩相当与JUnit4的@Before @After，做一些初始化和资源回收的事情，有3个Level

*  Trial 是默认值相当于 @BeforeClass @AfterClass
 *  Iteration 表示每一轮预热或者正式测试都执行一次
 *  Invocation 相当于 @Before @After,每次调用@Benchmark的函数都会执行一次，这个一般不要用，会干扰测试结果

@Param：轮换指定不同的调用参数测试

**2、JMH 陷阱**

在使用 JMH 的过程中，一定要避免一些陷阱。比如 JIT 优化中的死码消除，比如以下代码：

@Benchmark
    public void testStringAdd(Blackhole blackhole) {
        String a = "";
        for (int i = 0; i < length; i++) {
            a += i;
        }
    }

JVM 可能会认为变量 a 从来没有使用过，从而进行优化把整个方法内部代码移除掉，这就会影响测试结果。JMH 提供了两种方式避免这种问题，一种是将这个变量作为方法返回值 return a，一种是通过 Blackhole 的 consume 来避免 JIT 的优化消除。

在benchmark测试时，要注意几下几点：

*  某些数值计算在编译阶段就被算成常数了
 *  循环展开机制，编译器可能把循环300次自动优化成循环100次，每次循环递增调用3次等等
 *  一些没有副作用，返回值又没有赋值的函数，编译器或者JIT可能直接会整个函数调用都给直接省掉

其他陷阱还有常量折叠与常量传播、永远不要在测试中写循环、使用 Fork 隔离多个测试方法、方法内联、伪共享与缓存行、分支预测、多线程测试等，感兴趣的可以阅读 https://github.com/lexburner/JMH-samples 了解全部的陷阱。

**3、JMH 可视化**

除此以外，如果你想将测试结果以图表的形式可视化，可以试下这些网站：

*  JMH Visual Chart：http://deepoove.com/jmh-visual-chart/
 *  JMH Visualizer：https://jmh.morethan.io/

比如将上面测试例子结果的 json 文件导入，就可以实现可视化：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70][]

参考：

[https://mp.weixin.qq.com/s/k6t7yJLx73dWov835XVy3A][https_mp.weixin.qq.com_s_k6t7yJLx73dWov835XVy3A]

[http://code2life.top/2019/05/11/0043-jmh-benchmark/][http_code2life.top_2019_05_11_0043-jmh-benchmark]

[http_openjdk.java.net_projects_code-tools_jmh]: http://openjdk.java.net/projects/code-tools/jmh/
[20210701220650172.png]: /images/20221005/1151d4fb8e8d4f9fac816a7d6780fd99.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70]: /images/20221005/b52d0ad947dd45ef9bf97ad3a45f3aec.png
[https_mp.weixin.qq.com_s_k6t7yJLx73dWov835XVy3A]: https://mp.weixin.qq.com/s/k6t7yJLx73dWov835XVy3A
[http_code2life.top_2019_05_11_0043-jmh-benchmark]: http://code2life.top/2019/05/11/0043-jmh-benchmark/