性能测试中唯一标识的JMH测试

最新推荐文章于 2024-05-30 11:43:13 发布
最新推荐文章于 2024-05-30 11:43:13 发布
阅读量674 收藏 13
点赞数 14
分类专栏： 软件测试 技术分享 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83014911/article/details/139011903
版权

 

前文分享了几种性能测试中常用到的生成全局唯一标识的案例，虽然在文中我猜测了几种方案设计的性能，并根据自己的经验给出了适用的场景。

但对于一个性能测试工程师来讲，有真是测试数据才更有说服力。这让我想起来之前学过的Java微基准测试框架 JMH ，所以不妨一试。

JMH简介

JMH (Java Microbenchmark Harness)是一个用于编写和运行Java基准测试的工具。它被广泛用于评估Java应用程序的性能,并帮助开发人员发现和优化性能瓶颈。

JMH的主要特点包括:

  1. 高可信度:JMH提供了多种机制来消除测试过程中的噪音和偏差,确保测试结果的可靠性。

  2. 易用性:JMH提供了丰富的注解和API,使编写和运行基准测试变得相对简单。

  3. 灵活性:JMH支持多种测试模式,如简单的吞吐量测试、微基准测试以及更复杂的测试场景。

  4. 可扩展性:JMH允许用户自定义测试环境,如GC策略、编译器选项等,以满足特定的性能评估需求。

  5. 广泛应用:JMH被广泛应用于Java生态系统中,包括JDK自身的性能优化、第三方开源库的性能评估等。

JMH是Java开发者评估应用程序性能的强大工具,有助于提高Java应用程序的整体质量和性能。同样地对于性能测试而言，也可以通过 JMH 测试评估一段代码在实际执行当中的表现。

实测

除了 使用分布式服务生成GUID 这个方案以外，其他四种方案（其中两种是我自己常用的）均参与测试。原因是分布式服务需要网络交互，这个一听就不高性能，还有我暂时没条件测试这个。

下面有限展示实测结果，总结使用线程共享和线程独享的方案性能均远远高于 UUID 和 雪花算法 。为了省事儿以下测试均预热2次，预热批次大小2，测试迭代次数1次，迭代批次大小也是1次。配置如下：

  1.                 .warmupIterations(2)//预热次数

  2.                 .warmupBatchSize(2)//预热批次大小

  3.                 .measurementIterations(1)//测试迭代次数

  4.                 .measurementBatchSize(1)//测试批次大小

  5.                 .build();

PS：JMH 貌似还不支持 Groovy 所以我用 Java 写了这个用例。

下面是运行1个线程的测试结果：

  1. UniqueNumberTest.exclusive  thrpt       203.146          ops/us

  2. UniqueNumberTest.share      thrpt        99.860          ops/us

  3. UniqueNumberTest.snow       thrpt         4.096          ops/us

  4. UniqueNumberTest.uuid       thrpt        11.758          ops/us

下面是运行10个线程的测试结果：

  1. Benchmark                    Mode  Cnt     Score   Error   Units

  2. UniqueNumberTest.exclusive  thrpt       1117.347          ops/us

  3. UniqueNumberTest.share      thrpt        670.141          ops/us

  4. UniqueNumberTest.snow       thrpt         10.925          ops/us

  5. UniqueNumberTest.uuid       thrpt          3.608          ops/us

PS：此时机器的性能基本跑满了。

下面是40个线程的测试结果：

  1. Benchmark                    Mode  Cnt     Score   Error   Units

  2. UniqueNumberTest.exclusive  thrpt       1110.273          ops/us

  3. UniqueNumberTest.share      thrpt        649.350          ops/us

  4. UniqueNumberTest.snow       thrpt          8.908          ops/us

  5. UniqueNumberTest.uuid       thrpt          4.205          ops/us

可以看出跟10个线程结果差不多。

本机配置12核心，以上的测试结果单位是微秒，把结果乘以100万就是每秒的处理量，各位在使用不同方案时可以适当参考。

测试用例

下面是我的测试用例，测试结果我就不进行可视化了。

  1. package com.funtest.jmh;

  3. import com.funtester.utils.SnowflakeUtils;

  4. import org.openjdk.jmh.annotations.*;

  5. import org.openjdk.jmh.infra.Blackhole;

  6. import org.openjdk.jmh.results.format.ResultFormatType;

  7. import org.openjdk.jmh.runner.Runner;

  8. import org.openjdk.jmh.runner.RunnerException;

  9. import org.openjdk.jmh.runner.options.Options;

  10. import org.openjdk.jmh.runner.options.OptionsBuilder;

  12. import java.util.UUID;

  13. import java.util.concurrent.TimeUnit;

  14. import java.util.concurrent.atomic.AtomicInteger;

  16. @BenchmarkMode(Mode.Throughput)

  17. //@Warmup(Ω = 3, time = 2, timeUnit = TimeUnit.SECONDS)//预热次数,含义是每个测试会跑多久

  18. //@Measurement(iterations = 3, time = 5, timeUnit = TimeUnit.SECONDS)//测试迭代次数,含义是每个测试会跑多久

  19. //@Threads(1)//测试线程数

  20. //@Fork(2)//fork表示每个测试会fork出几个进程，也就是说每个测试会跑几次

  21. @State(value = Scope.Thread)//默认为Scope.Thread,含义是每个线程都会有一个实例

  22. @OutputTimeUnit(TimeUnit.MICROSECONDS)

  23. public class UniqueNumberTest {

  25. SnowflakeUtils snowflakeUtils = new SnowflakeUtils(1, 1);

  27. ThreadLocal<Integer> exclusive = ThreadLocal.withInitial(() -> 0);

  29. AtomicInteger share = new AtomicInteger(0);

  31. @Benchmark

  32. public void uuid() {

  33. UUID.randomUUID();

  34. }

  36. @Benchmark

  37. public void snow() {

  38. snowflakeUtils.nextId();

  39. }

  41. @Benchmark

  42. public void exclusive(Blackhole blackhole) {

  43. Integer i = exclusive.get();

  44. i++;

  45. blackhole.consume(i + "");

  46. }

  48. @Benchmark

  49. public void share(Blackhole blackhole) {

  50. blackhole.consume(share.incrementAndGet() + "");

  51. }

  53. public static void main(String[] args) throws RunnerException {

  54. Options options = new OptionsBuilder()

  55. .include(UniqueNumberTest.class.getSimpleName())//测试类名

  56. .result("long/result.json")//测试结果输出到result.json文件

  57. .resultFormat(ResultFormatType.JSON)//输出格式

  58. .forks(1)//fork表示每个测试会fork出几个进程，也就是说每个测试会跑几次

  59. .threads(40)//测试线程数

  60. .warmupIterations(2)//预热次数

  61. .warmupBatchSize(2)//预热批次大小

  62. .measurementIterations(1)//测试迭代次数

  63. .measurementBatchSize(1)//测试批次大小

  64. .build();

  65. new Runner(options).run();

  66. }

  69. }

总结：

感谢每一个认真阅读我文章的人！！！

作为一位过来人也是希望大家少走一些弯路，如果你不想再体验一次学习时找不到资料，没人解答问题，坚持几天便放弃的感受的话，在这里我给大家分享一些自动化测试的学习资源，希望能给你前进的路上带来帮助。

软件测试面试文档

我们学习必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有字节大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

 

          视频文档获取方式：
这份文档和视频资料，对于想从事【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴我走过了最艰难的路程，希望也能帮助到你！以上均可以分享，点下方小卡片即可自行领取。

程序员汤圆
关注
  • 14
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JMH 和 Arthas 定位问题的案例分享
xupeiyan的博客
02-24 104
问题描述 为了能够让我后面的实例能够贯穿这两个工具的使用，我首先简单描述下我们在开发中遇到的实际的性能问题。然后再引出这两个性能工具的实际使用，看我们如何使用这两个工具成功定位到性能瓶颈的。 问题如下：为了能够支持丢失率，我们将原先log4j2 的Async+自定义Appender的方式进行了修正，把异步的逻辑放到了自己改版后的Appender中。但我们发现修改后日志性能要比之前Async+自定义Appender的方式下降不少。这里由于隐私原因我并没有用实际公司中的实例，这里我用了一种其他同样能够体现问
jmh-perf-tests:各种JMH性能测试
05-02
在Hibernate项目上的微基准测试。 实验性的！
测试和性能监控神器 JMH & Arthas
天行健，君子以自强不息；地势坤，君子以厚德载物。
10-05 428
最近的工作日并不算太平，各种大大小小的case和解case，发现已经有好久好久没有静下心来专心写点东西了。不过倒还是坚持利用业余时间学习了不少微课上的东西，发现大佬们总结的东西还是不一样，...
神器 JMH & Arthas 性能监控
大数据星球-浪尖
10-10 335
简单介绍两款Java测试和性能监控神器最近的工作日并不算太平，各种大大小小的case和解case，发现已经有好久好久没有静下心来专心写点东西了。不过倒还是坚持利用业余时间学习了不少微课上的...
JMH和Arthas定位问题的案例分享
朱小厮的博客
02-11 243
点击上方“朱小厮的博客”，选择“设为星标”后台回复"书"，获取后台回复“k8s”，可领取k8s资料https://bryantchang.github.io/2019/12/08/java...
浅谈与性能相关的设计模式
农民工老王的博客
05-09 7663
大多数设计模式只是代码的一种组织方式，只有部分设计模式与性能相关，包括代理模式、单例模式、享元模式、原型模式等。本文将讲解这些可以提升性能的设计模式。
java 多线程并行 性能_Java 并行数据处理和性能分析
weixin_29948389的博客
02-13 498
并行流并行流是一个把元素分成多个块的流，每个块用不同的线程处理。可以自动分区，让所有的处理器都忙起来。假设要写一个方法，接受一个数量n做参数，计算1-n的和。可以这样实现：public long sequentialSum(long n) {return Stream.iterate(1L, i -> i + 1).limit(n).reduce(0L, Long::sum);}也许可以使用...
JMH 和 Arthas 定位问题的案例分享 ！
方志朋的博客
03-05 94
欢迎关注方志朋的博客，回复”666“获面试宝典https://bryantchang.github.io/2019/12/08/java-profile-tools/最近的工作日并不算太平...
JAVA设计模式优化性能
qq_27859801的博客
09-08 420
代码的结构对应用的整体性能，有着重要的影响。结构优秀的代码，可以避免很多潜在的性能问题，在代码的扩展性上也有巨大的作用；结构清晰、层次分明的代码，也有助于帮你找到系统的瓶颈点，进行专项优化。 设计模式就是对常用开发技巧进行的总结，它使得程序员之间交流问题，有了更专业、便捷的方式。 事实上，大多数设计模式并不能增加程序的性能，它只是代码的一种组织方式。本课时，我们将一一举例讲解和性能相关的几个设计模式，包括代理模式、单例模式、享元模式、原型模式等。 如何找到动态代理慢逻辑的原因? Spring 广泛使用了代理
Java 性能优化实战案例分析：如何用设计模式优化性能
fegus的博客
09-08 303
代码的结构对应用的整体性能，有着重要的影响。结构优秀的代码，可以避免很多潜在的性能问题，在代码的扩展性上也有巨大的作用；结构清晰、层次分明的代码，也有助于帮你找到系统的瓶颈点，进行专项优化。就是对常用开发技巧进行的总结，它使得程序员之间交流问题，有了更专业、便捷的方式。比如，我们在《02 | 理论分析：性能优化有章可循，谈谈常用的切入点》中提到，I/O 模块使用的是装饰器模式，你就能很容易想到 I/O 模块的代码组织方式。事实上，大多数设计模式并不能增加程序的性能，它只是代码的一种组织方式。
3.实战java高并发程序设计–JDK并发包—3.4　使用JMH进行性能测试
01-07
JMH（Java Microbenchmark Harness）是一个在OpenJDK项目中发布的，专门用于性能测试的框架，其精度可以到达毫秒级。通过JMH可以对多个方法的性能进行定量分析。比如，当要知道执行一个函数需要多少时间，或者当对一...
微基准测试工具：jmh
01-13
JMH是Java性能测试工具，主要是对工程中一些方法进行一些基准测试，支持的时间单位为：nano / micro / milli / macro
基准测试神器 – JMH [ Java Microbenchmark Harness ]
12-20
Table of Contents 一. 简介 二. 安装 [ idea plug ] 三....@Benchmark @Warmup @Measurement @BenchmarkMode ...四.... 4.1....4.2.测试map的循环输出效率 ...4.3.测试list的循环效果 ...JMH，全称 Java Microbenchmark Har
JMH - Java 微基准测试工具（自助性能测试）完整可运行代码
02-12
JMH - Java 微基准测试工具（自助性能测试）完整可运行代码
如何mysql数据导入到mongdb
codemami的博客
05-30 774
由于MySQL和MongoDB的数据模型不同（例如，MySQL使用关系模型，而MongoDB使用文档模型），你可能需要转换数据的格式。使用MongoDB驱动程序：你也可以使用MongoDB的官方驱动程序（如Python的pymongo）来编写脚本，将数据直接插入到MongoDB中。注意：如果你的JSON文件包含多个文档，并且它们不是作为数组的一部分（即每个文档都在其自己的行上），则需要使用--jsonArray选项。手动转换：对于小型数据集，你可以手动编辑SQL或CSV文件，将其转换为JSON格式。
学 Python 具体能干什么？
猿小白的博客
05-26 1241
Python 是一种功能强大、用途广泛的编程语言，因其简洁易读的语法和丰富的库生态系统而备受欢迎。
在linux服务器上使用tensorboard，错误记录
最新发布
wwwwzm的博客
05-30 480
1. 使用tensorboard命令时，不是从虚拟环境中找tensorboard，而是从（全局路径）中找（/home/ljx/.local/lib/python3.9/site-packages/tensorboard）是一个在 Unix-like 系统（包括 Linux 和 macOS）的命令行界面（如 Bash shell）中使用的命令。2.使用which命令， 查看使用的tensorboard的路径，发现使用的是全局路径，不是虚拟环境路径。是一个特殊的变量，它定义了操作系统搜索可执行文件的目录。
Pandas03
Bianca427的博客
05-27 1227
聚合计算时新增一列计算最大值与平均值的差值df.groupby('district').agg(最低工资=('salary', 'min'), 最高工资=('salary', 'max'), 平均工资=('salary', 'mean'), 最大值与均值差值=('salary', myfunc)).rename_axis(["行政区"])
jmh 测试并行流和串行流
05-18
好的，我可以给你一个简单的示例来比较并行流和串行流在 jmh 测试中的性能差异。 假设我们有一个包含 1 百万个整数的列表，并且我们要计算这些数的总和。我们可以使用 Java 8 中的 Stream API 来实现这个任务，而且可以选择使用并行流或串行流来执行计算。 首先，我们来看一下串行流的实现代码： ```java public class SerialStreamBenchmark { private List<Integer> numbers; @Setup public void setup() { numbers = new ArrayList<>(); for (int i = 0; i < 1_000_000; i++) { numbers.add(i); } } @Benchmark public int sum() { return numbers.stream().mapToInt(Integer::intValue).sum(); } } ``` 在上述代码中，我们通过 `@Setup` 注解来初始化包含 1 百万个整数的列表。`@Benchmark` 注解标记了 `sum()` 方法，该方法将列表转换为流，然后通过 `mapToInt()` 方法将流中的元素映射为整数，并最终调用 `sum()` 方法计算它们的总和。 接下来，我们来看一下并行流的实现代码： ```java public class ParallelStreamBenchmark { private List<Integer> numbers; @Setup public void setup() { numbers = new ArrayList<>(); for (int i = 0; i < 1_000_000; i++) { numbers.add(i); } } @Benchmark public int sum() { return numbers.parallelStream().mapToInt(Integer::intValue).sum(); } } ``` 与串行流的实现代码类似，我们只需要将 `stream()` 方法替换为 `parallelStream()` 方法即可将流转换为并行流。 接下来，我们可以使用 jmh 测试这两个实现的性能差异。以下是测试类的代码： ```java public class StreamBenchmarkTest { @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MILLISECONDS) @Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) @Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS) @Fork(1) @State(Scope.Thread) public static class SerialStreamBenchmarkTest { SerialStreamBenchmark serialStreamBenchmark = new SerialStreamBenchmark(); @Setup public void setup() { serialStreamBenchmark.setup(); } @Benchmark public int sum() { return serialStreamBenchmark.sum(); } } @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MILLISECONDS) @Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) @Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS) @Fork(1) @State(Scope.Thread) public static class ParallelStreamBenchmarkTest { ParallelStreamBenchmark parallelStreamBenchmark = new ParallelStreamBenchmark(); @Setup public void setup() { parallelStreamBenchmark.setup(); } @Benchmark public int sum() { return parallelStreamBenchmark.sum(); } } public static void main(String[] args) throws RunnerException { Options options = new OptionsBuilder() .include(StreamBenchmarkTest.class.getSimpleName()) .build(); new Runner(options).run(); } } ``` 在上述代码中，我们使用了 `@BenchmarkMode`、`@OutputTimeUnit`、`@Warmup`、`@Measurement`、`@Fork` 和 `@State` 注解来配置 jmh 测试。其中，`@State` 注解指定了测试类的状态，`@Setup` 注解用于初始化测试数据。 最后，我们运行测试类，就可以得到并行流和串行流的性能测试结果了。 需要注意的是，实际的测试结果可能因为硬件环境和测试数据的不同而有所不同，这里只是提供了一个简单的示例来比较并行流和串行流在 jmh 测试中的性能差异。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值