JMH - 微基准测试

已于 2024-08-20 17:12:48 修改
阅读量2.3k 收藏 5
点赞数
分类专栏： 并发编程 文章标签： java
于 2021-05-08 17:18:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y_bccl27/article/details/116534686
版权
本文展示了如何利用Spring框架中的org.springframework.util.CollectionUtils.isEmpty()方法来判断List集合是否为空。通过三个示例，分别演示了空List、null List以及包含元素的List的情况，说明该方法能正确判断集合的空状态。
摘要由CSDN通过智能技术生成

一、介绍

JMH全称“Java Microbenchmark Harness（微基准测试框架）”，是专门用于Java代码微基准测试的一套测试工具API，是由OpenJDK/Oracle官方发布的工具。

二、快速使用

在pom.xml文件中引入下述依赖：

<dependency>
	<groupId>org.openjdk.jmh</groupId>
	<artifactId>jmh-core</artifactId>
	<version>1.33</version>
</dependency>

<dependency>
	<groupId>org.openjdk.jmh</groupId>
	<artifactId>jmh-generator-annprocess</artifactId>
	<version>1.33</version>
	<scope>provided</scope>
</dependency>

构建基准测试的“HelloWorld”示例，用于测试String与StringBuffer拼接字符串的吞吐量： 

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.TimeUnit;

@BenchmarkMode({Mode.Throughput})
@OutputTimeUnit(TimeUnit.SECONDS)
@Fork(value = 1)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Threads(1)
public class HelloWorld {

    @Benchmark
    public void measureBuffer() {
        String[] helloWorld = {"h", "e", "l", "l", "o", "W", "o", "r", "l", "d"};
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < helloWorld.length; i++) {
            stringBuffer.append(helloWorld[i]);
        }
    }

    @Benchmark
    public void measureGeneral() {
        String[] helloWorld = {"h", "e", "l", "l", "o", "W", "o", "r", "l", "d"};
        String data = "";
        for (int i = 0; i < helloWorld.length; i++) {
            data = data + helloWorld[i];
        }
    }

    public static void main(String[] args) throws Exception {
        Options opts = new OptionsBuilder()
                .include(HelloWorld.class.getSimpleName())
                .resultFormat(ResultFormatType.CSV)
                .build();
        new Runner(opts).run();
    }
}

执行上述入门示例的main方法，其输出结果如下： 

可以看到StringBuffer拼接字符串的吞吐量要远比String拼接字符串的吞吐量大很多，因此在使用上关于字符串拼接优先使用StringBuffer，并且它是线程安全的。 

三、注解介绍

3.1 @BenchmarkMode

该注解一般作用在公共类上，其取值是一个列表，其配置示例为“@BenchmarkMode({Mode.Throughput, Mode.AverageTime})”，共有下述五种取值：

Mode.Throughput：表示测试的是吞吐量。

Mode.AverageTime：表示测试的是平均时间，即每次调用平均耗时。

Mode.SampleTime：表示测试的是随机取样（具体这个的作用是什么，目前我还不知道）

Mode.SingleShotTime：顾名思义，只运行一次，一般用于测试冷启动性能。

Mode.All：表示的是将前面这四种类型全部进行测试

3.2 @OutputTimeUnit 

该注解表示测试结果的时间单位，其配置示例为“@OutputTimeUnit(TimeUnit.SECONDS)”。

  • TimeUnit.MILLISECONDS： 表示毫秒
  • TimeUnit.SECONDS：表示秒

3.3 @Benchmark

该注解用于标识需要进行基准测试的方法，类比JUnit的@Test。这个注解告诉JMH，‌被注解的方法是需要进行性能测试的目标。‌通过使用@Benchmark注解，‌开发者可以指定哪些方法需要进行性能测试，‌从而帮助评估代码的性能并进行优化。‌

3.4 @Fork

如果@Fork注解的value值为3的话，则JMH会fork出3组进程来进行测试。

3.5 @Warmup

该注解表示“预热”阶段的配置，注解中iterations属性的值为1则表示在每一组进程中会进行1轮的预热。注解中time属性的值为2，timeUnit属性的值为TimeUnit.SECONDS，则表示每一轮预热处理的总时间为2秒。

3.6 @Measurement

该注解表示“压测”阶段的配置，注解中iterations属性的值为1则表示在每一组进程中会进行1轮的压测。注解中time属性的值为2，timeUnit属性的值为TimeUnit.SECONDS，则表示每一轮压测的总时间为2秒。

3.7 @Threads

该注解表示在每一轮“预热”和“压测”处理中的线程数设置有多少个。

3.8 @State

该标签用于指定一个属性共享的范围（了解这个标签前，先看完下面的文章，需要对基准测试有一个大概的认识） 

3.8.1 基准测试内线程内共享

在JMH类中定义如下这个属性（静态内部类）：

@State(Scope.Thread)
public static class ThreadState {
    volatile double k = 1;
}

然后再对应的Benchmark方法当中使用：

@Benchmark
public void measureUnshared(ThreadState state) throws InterruptedException {
    state.k++;
    Thread.sleep(500);
    System.out.println("thread name = " + Thread.currentThread().getName() + "  ,state= " + state.hashCode() + "  ,k " +
            "= " + state.k);
}

基准方法可以引用状态，并且JMH将在调用这些方法时注入适当的状态。  在上面的基准方法当中就包含了一个状态，在这个方法运行时，JMH会自动注入这个对象。

开启4个线程来测试，对应的主类方法如下：

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.TimeUnit;

@BenchmarkMode({Mode.Throughput})
@OutputTimeUnit(TimeUnit.SECONDS)
@Fork(value = 1)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Threads(4)
public class HelloWorld {

    @State(Scope.Thread)
    public static class ThreadState {
        volatile double k = 1;
    }

    @Benchmark
    public void measureUnshared(ThreadState state) throws InterruptedException {
        state.k++;
        Thread.sleep(500);
        System.out.println("thread name = " + Thread.currentThread().getName() + "  ,state= " + state.hashCode() + "  ,k " +
                "= " + state.k);
    }

    public static void main(String[] args) throws Exception {
        Options opts = new OptionsBuilder()
                .include(HelloWorld.class.getSimpleName())
                .resultFormat(ResultFormatType.CSV)
                .build();
        new Runner(opts).run();
    }
}

以下为第一轮预热的结果：

从这个结果可以看出，JMH使用了四个线程，这个四个线程使用的state对象都是不同的（从hashCode不同可以看），每个都有自己的独一份，也就是说通过 @State(Scope.Thread) 将这个对象限定为线程内部共享了。在上面同一个线程中，下一轮测试会使用上面的值，比如以下为预热完成之后，真正开始测试的第一轮结果。

从这个结果可以看出，Measurement阶段与Warmup阶段使用的线程相同，线程内的对象也是同一个对象，对象内的变量被共享（k的值持续增加）。

3.8.2 基准测试内线程间共享

如果想一个变量在同一个基础测试内被所有线程共享，可定义对象如下：

@State(Scope.Benchmark)
public static class ThreadState {
    volatile double k = 1;
}
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.TimeUnit;

@BenchmarkMode({Mode.Throughput})
@OutputTimeUnit(TimeUnit.SECONDS)
@Fork(value = 1)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Threads(4)
public class HelloWorld {

@State(Scope.Benchmark)
public static class ThreadState {
    volatile double k = 1;
}

    @Benchmark
    public void measureShared(ThreadState state) throws InterruptedException {
        state.k++;
        Thread.sleep(1000);
        System.out.println("thread name = " + Thread.currentThread().getName() + "  ,state= " + state.hashCode() + "  ,k " +
                "= " + state.k);
    }

    public static void main(String[] args) throws Exception {
        Options opts = new OptionsBuilder()
                .include(HelloWorld.class.getSimpleName())
                .resultFormat(ResultFormatType.CSV)
                .build();
        new Runner(opts).run();
    }
}

 从这里可以看出两个结论：第一个就是不同的线程之间确实是共享了同一个对象，但是共享对象中的变量值看起来好像不对（总量是对的，但是单次取的值不对）。目前这个小问题，不是重点，重点是了解其相关注解的作用。

四、吞吐量测试（推荐使用）

Mode.AverageTime 表示测量吞吐量，即单位时间内可以运行多少次。

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.TimeUnit;

@BenchmarkMode({Mode.Throughput})
@OutputTimeUnit(TimeUnit.SECONDS)
@Fork(value = 1)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Threads(1)
public class HelloWorld {

    @Benchmark
    public void measureThroughput() {
        String[] helloWorld = {"h", "e", "l", "l", "o", "W", "o", "r", "l", "d"};
        String data = "";
        for (int j = 0; j < helloWorld.length; j++) {
            data = data + helloWorld[j];
        }
    }

    public static void main(String[] args) throws Exception {
        Options opts = new OptionsBuilder()
                .include(HelloWorld.class.getSimpleName())
                .resultFormat(ResultFormatType.CSV)
                .build();
        new Runner(opts).run();
    }
}

运行的时候会在控制台打印结果，下面对测试结果做简要分析。

以下为预热的吞吐量和测试的吞吐量，其中的ops/s表示每秒操作次数： 

五、平均耗时测试

Mode.AverageTime 表示测量平均执行时间，它的执行方式类似于 Mode.Throughput。有人可能会说这是吞吐量的倒数，的确如此，在某些工作负载中，测量时间更方便。 

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.TimeUnit;

@BenchmarkMode({Mode.AverageTime})
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Fork(value = 1)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Threads(1)
public class HelloWorld {

    @Benchmark
    public void measureAvgTime() {
        String[] helloWorld = {"h", "e", "l", "l", "o", "W", "o", "r", "l", "d"};
        String data = "";
        for (int i = 1; i <= 5000; i++) {
            for (int j = 0; j < helloWorld.length; j++) {
                data = data + helloWorld[j];
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Options opts = new OptionsBuilder()
                .include(HelloWorld.class.getSimpleName())
                .resultFormat(ResultFormatType.CSV)
                .build();
        new Runner(opts).run();
    }
}

执行上述代码，在输出结果中可以看到其平均耗时在200ms左右： 

特别说明：JMH基准测试的时间和实际应用程序中日志打印的时间不一样，主要是因为JMH专注于测量代码本身的执行时间，而忽略了日志打印等外部开销，同时还会受到CPU调度和外部系统响应时间的影响‌。

y_bccl27
关注
专栏目录
java 判断list是否为空过程解析
08-25
主要介绍了java 判断list是否为空过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java中判断list是否为空的用法(亲测)
gb4215287的博客
10-05 1万+
1、如果想判断list是否为空，可以这么判断： if(null == list || list.size() ==0 ){ 　　//为空的情况 }else{ 　　//不为空的情况 } 2、list.isEmpty() 和 list.size()==0 有啥区别呢 　　　　答案：没有区别 。isEmpty()判断有没有元素，而size()返回有几个元素， 如果判断一个集合有无元素 建议用isEmpty()方法.比较符合逻辑用法。 3、list！=null 跟 ！ list.isEmpt...
判断list集合是否为空的方法
cxfjava的博客
01-09 4924
list.isEmpty()    或   list.size()==0
java：判断list为空
问道于旁
10-30 521
if(null == list || list.size() ==0 ){ }
java中list集合判空方式
最新发布
java_ljc88的博客
09-22 6018
java中list集合判空方式
jmh-gradle-plugin：将JMH基准测试框架与Gradle集成
02-04
它提供了一套强大的工具，帮助开发者编写、运行和分析微基准测试，以衡量代码片段的性能。而`jmh-gradle-plugin`则是这个框架与流行的构建工具Gradle的整合插件，使得在Gradle项目中使用JMH变得简单易行。 **一、...
JMH - Java 微基准测试工具（自助性能测试）完整可运行代码
02-12
Java Micro Benchmark Harness（简称JMH）是Oracle JDK项目的一个子项目，它提供了一套用于开发、执行和分析Java和Java虚拟机（JVM）微基准测试的框架。JMH的目标是帮助开发者正确地进行性能测试，避免常见的陷阱，...
使用JMH进行微基准测试不要猜，要测试！Java开发Jav
11-22
本文将深入探讨如何使用JMH进行微基准测试，分享一些相关的Java开发经验和技巧。 1. **了解JMH** JMH是Java平台上的一个开源框架，用于创建、运行和分析微基准测试。它的核心理念是避免常见的基准测试陷阱，如过度...
jmh-benchmarks:测试新旧风格的数组循环
07-16
此 repo 用于通过使用 JMH 作为微基准测试框架来比较旧式数组循环和 java 8 流。 跑步： mvn 清洁包 java -jar target/benchmarks.jar 您可以使用参数“-wi, -i ...”来排列迭代次数。 有关 jmh 的更多信息：
JMH -- JAVA 微基准测试工具套件
不能放弃治疗
12-08 262
文章目录1、概览2、jmh 简介3、jmh 使用demo4、jmh 常用设置介绍5、注意事项 你的努力，终将成就无可替代的自己 将来的你一定会感谢现在拼命的自己 1、概览 在日常开发中，我们往往需要优化我们自己写的代码。优化后的代码，执行效率是否比之前的还高？具体高多少？这些都是需要去测量。 目前比较主流的做法是使用 jmh 进行微基准测试。 2、jmh 简介 jmh 是 java 用于微基准测试工具套件。主要是基于方法层面的基准测试，精度可达纳秒级。由 oracle 实现 JIT 大牛编写而成。 在使
java中判断list是否为空
热门推荐
qq_41644069的博客
12-09 4万+
1.判断list是否为空 如果想判断list是否为空，可以这样判断： //方法1 if (list != null && !list.isEmpty()) { //list不为空 } else { //list为空 } //方法2 if (list != null && list.size() > 0) { //list不为空 } else { //list为空 } //方法3 if (list == null ||
java判断集合list是否为空
鹏神丶明月天
07-14 1万+
方法有二：其一为： 其二为：这是最常用的方法，简单便捷使用 方法，isEmpty()判断list集合有没有元素，如果有元素返回false，没有返回true，如果集合本身设置为null，则会报空指针异常，如这样：List list = null;...
java list 判空_Java中对list集合进行判空
weixin_34644072的博客
02-12 8854
在工作中，我们进场会对list集合进行判空，刚开始只是习惯写上if(list!=null || list.size()>0)，后来发现集合中还有.isEmpty()的判断方法，以及list中有一个属性，但是这个属性时null的情况，本着不管多细小都值得牢记的原则，这里记录一下回头得研究一下博客园里记笔记的方式和排版了，我总感觉是不是有隐藏的东西没发现(1)第一种：list != null使用...
Java 判断list是否为空，有图易懂
【CSDN】
07-06 1516
java中判断list是否为空可以有两种方式，且这两种方式是等价的 if(list == null || list.size() == 0 ){ 　　//为空的情况 }else{ 　　//不为空的情况 } if(list!=null && !list.isEmpty()){ 　　　//不为空的情况 }else{ 　　　//为空的情况 } 其中list.size() == 0 跟list.isEmpty()是等价的。一般使用第二种方式 if(list!=nul...
List判断为空
weixin_43652507的博客
12-31 3264
List判断为空
判断一个list集合是否为空，用isEmpty 还是 null
qq_44625745的博客
06-04 9639
1.isEmpty() 用于判断List内容是否为空，即list里一个元素也没有， 但是必须在 List list 本身不是空的引用的情况下才行。 即对象本身不能是空对象。2.null一般判断该List的引用也空的情况下实战开发项目错误 判断集合为空错误：一开始我一直用 list !=null 来判断集合里是否有元素，这个是不对 要用isEmpty()判断集合时候有元素，或者用size>0 来判断集合元素个数 集合有元素。 报空指针异常 结果: Exception in thread “main”
Java中判断list为空(CollectionUtils.isEmpty)
zhuoya_的博客
03-02 3万+
@Test public void testStr() { /*----------------【Start】isEmpty方法检查-----------------*/ List<String> strList1 = Lists.newArrayList(); System.out.println(Collection...
CollectionUtils.isEmpty
developer
10-22 4万+
集合判断：　　例1: 判断集合是否为空: 　　CollectionUtils.isEmpty(null): true 　　CollectionUtils.isEmpty(new ArrayList()): true　　 　　CollectionUtils.isEmpty({a,b}): false　　例2: 判断集合是否不为空: 　　CollectionUtils.isNotEmpty(null...
java判断集合是否为空
韩金群的博客
03-04 1万+
java判断集合是否为空
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值