JMH
JMH(Java Microbenchmark Harness)是由OpenJDK Developer提供的基准测试工具(基准可以理解为比较的基础,我们将这一次性能测试结果作为基准结果,下一次的测试结果将与基准数据进行比较),它是一种常用的性能测试工具,解决了基准测试中常见的一些问题。
结果分析
结果可视化可用 JMH Visualizer,把 JSON 结果拖入即可生成图表。

结果日志解释
- 基础信息,显示Java路径、Java版本以及JMH基础配置信息
# JMH version: 1.21
# VM version: JDK 1.8.0_275, OpenJDK 64-Bit Server VM, 25.275-b01
# VM invoker: /Library/Java/JavaVirtualMachines/adoptopenjdk-8.jdk/Contents/Home/jre/bin/java
# VM options: -server
# Warmup: 1 iterations, 10 s each
# Measurement: 1 iterations, 10 s each
# Timeout: 10 min per iteration
# Threads: 8 threads, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: cn.z201.jmh.ListBenchmark.testArrayList
# Parameters: (size = 100)
- 预热次数。预热测试不会作为最终的统计结果。预热的目的是让 JVM 对被测代码进行足够多的优化,被测代码应该得到了充分的 JIT 编译和优化。
# Warmup Iteration 1: 0.002 ±(99.9%) 0.001 ms/op
Iteration 1: 0.002 ±(99.9%) 0.001 ms/op
Result "cn.z201.jmh.ListBenchmark.testArrayList":
0.002 ms/op
- 结果表明,元素数量越多,
LinkedList.add()越占优势:它用双向链表在尾部追加,不需要像ArrayList那样扩容搬移;CopyOnWriteArrayList每次写入都复制整个数组,一万次时耗时达到 148 ms,只适合读多写少的场景。
Benchmark (size) Mode Cnt Score Error Units
ListBenchmark.testArrayList 100 avgt 0.002 ms/op
ListBenchmark.testArrayList 1000 avgt 0.018 ms/op
ListBenchmark.testArrayList 10000 avgt 0.194 ms/op
ListBenchmark.testCopyOnWriteArrayList 100 avgt 0.015 ms/op
ListBenchmark.testCopyOnWriteArrayList 1000 avgt 1.386 ms/op
ListBenchmark.testCopyOnWriteArrayList 10000 avgt 148.161 ms/op
ListBenchmark.testLinkedList 100 avgt 0.002 ms/op
ListBenchmark.testLinkedList 1000 avgt 0.017 ms/op
ListBenchmark.testLinkedList 10000 avgt 0.163 ms/op
注解使用
@BenchmarkMode
用来配置 Mode 选项,可用于类或者方法上,这个注解的 value 是一个数组,可以把几种 Mode 集合在一起执行,如:@BenchmarkMode({Mode.SampleTime, Mode.AverageTime}),还可以设置为 Mode.All,即全部执行一遍。
Throughput:整体吞吐量,每秒执行了多少次调用,单位为
ops/timeAverageTime:用的平均时间,每次操作的平均时间,单位为
time/opSampleTime:随机取样,最后输出取样结果的分布
SingleShotTime:只运行一次,往往同时把 Warmup 次数设为 0,用于测试冷启动时的性能
All:上面的所有模式都执行一次
@State
通过 State 可以指定一个对象的作用范围,JMH 根据 scope 来进行实例化和共享操作。@State 可以被继承使用,如果父类定义了该注解,子类则无需定义。由于 JMH 允许多线程同时执行测试,不同的选项含义如下:
Scope.Benchmark:所有测试线程共享一个实例,测试有状态实例在多线程共享下的性能
Scope.Group:同一个线程在同一个 group 里共享实例
Scope.Thread:默认的 State,每个测试线程分配一个实例
@OutputTimeUnit
- 为统计结果的时间单位,可用于类或者方法注解
@Warmup
预热所需要配置的一些基本测试参数,可用于类或者方法上。一般前几次进行程序测试的时候都会比较慢,所以要让程序进行几轮预热,保证测试的准确性。参数如下所示:
iterations:预热的次数
time:每次预热的时间
timeUnit:时间的单位,默认秒
batchSize:批处理大小,每次操作调用几次方法
JVM 的 JIT 机制,如果某个函数被调用多次之后,JVM 会尝试将其编译为机器码,从而提高执行速度,所以为了让 benchmark 的结果更加接近真实情况就需要进行预热。
@Measurement
- 实际调用方法所需要配置的一些基本测试参数,可用于类或者方法上,参数和
@Warmup相同。
@Threads
- 每个进程中的测试线程,可用于类或者方法上。
@Fork
- 进行 fork 的次数,可用于类或者方法上。如果 fork 数是 2 的话,则 JMH 会 fork 出两个进程来进行测试。
@Param
- 指定某项参数的多种情况,特别适合用来测试一个函数在不同的参数输入的情况下的性能,只能作用在字段上,使用该注解必须定义 @State 注解。
- 如果只是用
@Param在编译时会报错,它必须配合@State注解使用,@State指定了对象共享范围。- @State(value = Scope.Benchmark):基准测试内共享对象
- @State(value = Scope.Group):同一个线程组内共享
- @State(value = Scope.Thread):同一个线程内共享
@Setup 与 @TearDown
- 假如初始化和销毁代码并不是基准测试的一部分,为了减少测试噪,音所以不应该放到
@Benchmark修饰的方法内部,JMH提供了@Setup和@TearDown实现这样的功能。
案例一
比较字符串
+拼接、StringBuilder.append、StringBuffer.append的开销
- 分别添加100、1000、10000次字符串。

演示代码
package cn.z201.jmh;
/**
* @author z201.coding@gmail.com
**/
@State(Scope.Benchmark)
public class StringBenchmark {
private final static Integer MEASUREMENT_ITERATIONS = 1;
private final static Integer WARMUP_ITERATIONS = 1;
@Param(value = {"100","1000","10000"})
private int size;
public List<Integer> stringList = null;
@Setup(Level.Trial)
public synchronized void initialize() {
try {
stringList = new Random()
.ints()
.limit(size)
.boxed()
.map(i->i.toString())
.collect(Collectors.toList());
} catch (Exception e) {
e.printStackTrace();
}
}
// Throughput 整体吞吐量,例如”1秒内可以执行多少次调用”。
// AverageTime: 调用的平均时间,例如”每次调用平均耗时xxx毫秒”。
// SampleTime: 随机取样,最后输出取样结果的分布,例如”99%的调用在xxx毫秒以内,99.99%的调用在xxx毫秒以内”
// SingleShotTime: 以上模式都是默认一次 iteration 是 1s,唯有 SingleShotTime 是只运行一次。往往同时把 warmup 次数设为0,用于测试冷启动时的性能。
// All(“all”, “All benchmark modes”);
@Test
public void executeJmhRunner() throws RunnerException {
Options opt = new OptionsBuilder()
// 设置类名正则表达式基准为搜索当前类
.include("\\." + StringBenchmark.class.getSimpleName() + "\\.")
// 都是一些基本的参数,可以根据具体情况调整。一般比较重的东西可以进行大量的测试,放到服务器上运行。
.warmupIterations(WARMUP_ITERATIONS) // 多少次预热
.measurementIterations(MEASUREMENT_ITERATIONS) // 要做多少次测量
.timeUnit(TimeUnit.MILLISECONDS) // 毫秒
// 不额外 fork 进程,测试与主进程运行在同一个 JVM,仅适合调试
.forks(0)
.threads(8) // 每个进程中的测试线程数,一般取 CPU 核数的 2 倍
.mode(Mode.AverageTime)
.shouldDoGC(true)
.shouldFailOnError(true)
.resultFormat(ResultFormatType.JSON) // 输出格式化
// .result("/dev/null") // set this to a valid filename if you want reports
.result("benchmark.json")
.shouldFailOnError(true)
.jvmArgs("-server")
.build();
new Runner(opt).run();
}
@Benchmark
public void testStringConcat(Blackhole blackhole){
String str = "";
for (String s : stringList) {
str += s;
}
blackhole.consume(str);
}
@Benchmark
public void testStringBuffer(Blackhole blackhole){
StringBuffer stringBuffer = new StringBuffer();
stringList.stream().forEach(i-> stringBuffer.append(i.toString()));
blackhole.consume(stringBuffer);
}
@Benchmark
public void testStringBuilder(Blackhole blackhole){
StringBuilder stringBuilder = new StringBuilder();
stringList.stream().forEach(i-> stringBuilder.append(i.toString()));
blackhole.consume(stringBuilder);
}
}
案例二
比较ArrayList.add 、LinkedList.add、CopyOnWriteArrayList.add
- 分别添加100、1000、10000次

演示代码
/**
* @author z201.coding@gmail.com
**/
@State(Scope.Benchmark)
public class ListBenchmark {
private final static Integer MEASUREMENT_ITERATIONS = 1;
private final static Integer WARMUP_ITERATIONS = 1;
@Param(value = {"100","1000","10000"})
private int size;
public List<String> stringList = null;
@Setup(Level.Trial)
public synchronized void initialize() {
try {
stringList = new Random()
.ints()
.limit(size)
.boxed()
.map(i->i.toString())
.collect(Collectors.toList());
} catch (Exception e) {
e.printStackTrace();
}
}
// Throughput 整体吞吐量,例如”1秒内可以执行多少次调用”。
// AverageTime: 调用的平均时间,例如”每次调用平均耗时xxx毫秒”。
// SampleTime: 随机取样,最后输出取样结果的分布,例如”99%的调用在xxx毫秒以内,99.99%的调用在xxx毫秒以内”
// SingleShotTime: 以上模式都是默认一次 iteration 是 1s,唯有 SingleShotTime 是只运行一次。往往同时把 warmup 次数设为0,用于测试冷启动时的性能。
// All(“all”, “All benchmark modes”);
@Test
public void executeJmhRunner() throws RunnerException {
Options opt = new OptionsBuilder()
// 设置类名正则表达式基准为搜索当前类
.include("\\." + getClass().getSimpleName() + "\\.")
// 都是一些基本的参数,可以根据具体情况调整。一般比较重的东西可以进行大量的测试,放到服务器上运行。
.warmupIterations(WARMUP_ITERATIONS) // 多少次预热
.measurementIterations(MEASUREMENT_ITERATIONS) // 要做多少次测量
.timeUnit(TimeUnit.MILLISECONDS) // 毫秒
// 不额外 fork 进程,测试与主进程运行在同一个 JVM,仅适合调试
.forks(0)
.threads(8) // 每个进程中的测试线程数,一般取 CPU 核数的 2 倍
.mode(Mode.AverageTime)
.shouldDoGC(true)
.shouldFailOnError(true)
.resultFormat(ResultFormatType.JSON) // 输出格式化
// .result("/dev/null") // set this to a valid filename if you want reports
.result("ListBenchmark.json")
.shouldFailOnError(true)
.jvmArgs("-server")
.build();
new Runner(opt).run();
}
@Benchmark
public void testArrayList(Blackhole blackhole){
List<String> arrayList = new ArrayList<>();
stringList.stream().forEach(i->arrayList.add(i));
blackhole.consume(arrayList);
}
@Benchmark
public void testLinkedList(Blackhole blackhole){
List<String> linkedList = new LinkedList<>();
stringList.stream().forEach(i->linkedList.add(i));
blackhole.consume(linkedList);
}
@Benchmark
public void testCopyOnWriteArrayList(Blackhole blackhole){
List<String> copyOnWriteArrayList = new CopyOnWriteArrayList<>();
stringList.stream().forEach(i->copyOnWriteArrayList.add(i));
blackhole.consume(copyOnWriteArrayList);
}
}
案例三
JMH 官方提供了生成 jar 包的方式来执行
- 对比AtomicLong 、VolatileLong 、log求和

打包项目
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>2.4.1</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<finalName>jmh</finalName>
<transformers>
<transformer
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>cn.z201.jmh.Main</mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
测试代码
/**
* @author z201.coding@gmail.com
**/
@State(Scope.Benchmark)
public class Main {
private final static Integer MEASUREMENT_ITERATIONS = 1;
private final static Integer WARMUP_ITERATIONS = 1;
@Param(value = {"100", "1000", "10000"})
private int size;
public List<Integer> numberList = null;
@Setup(Level.Trial)
public synchronized void initialize() {
try {
numberList = new Random()
.ints()
.limit(size)
.boxed()
.collect(Collectors.toList());
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws RunnerException {
Options opt = new OptionsBuilder()
// 设置类名正则表达式基准为搜索当前类
.include("\\." + Main.class.getSimpleName() + "\\.")
// 都是一些基本的参数,可以根据具体情况调整。一般比较重的东西可以进行大量的测试,放到服务器上运行。
.warmupIterations(WARMUP_ITERATIONS) // 多少次预热
.measurementIterations(MEASUREMENT_ITERATIONS) // 要做多少次测量
.timeUnit(TimeUnit.MILLISECONDS) // 毫秒
// 不额外 fork 进程,测试与主进程运行在同一个 JVM,仅适合调试
.forks(0)
.threads(8) // 每个进程中的测试线程数,一般取 CPU 核数的 2 倍
.mode(Mode.AverageTime)
.shouldDoGC(true)
.shouldFailOnError(true)
.resultFormat(ResultFormatType.JSON) // 输出格式化
// .result("/dev/null") // set this to a valid filename if you want reports
.result("Main.json")
.shouldFailOnError(true)
.jvmArgs("-server")
.build();
new Runner(opt).run();
}
public static class VolatileLong {
private volatile long value = 0;
public synchronized void add(long amount) {
this.value += amount;
}
public long getValue() {
return this.value;
}
}
@Benchmark
public void atomicLong(Blackhole blackhole) {
AtomicLong atomicLong = new AtomicLong();
numberList.parallelStream().forEach(atomicLong::addAndGet);
blackhole.consume(atomicLong.get());
}
@Benchmark
public void volatileLong(Blackhole blackHole) {
VolatileLong volatileLong = new VolatileLong();
numberList.parallelStream().forEach(volatileLong::add);
blackHole.consume(volatileLong.getValue());
}
@Benchmark
public void longStreamSum(Blackhole blackHole) {
long sum = numberList.parallelStream().mapToLong(s -> s).sum();
blackHole.consume(sum);
}
}
启动
➜ JMH git:(main) ✗ cd target
➜ target git:(main) ✗ java -jar jmh.jar
Spring Boot 集成
在 Spring 测试中做基准测试,关键是把容器启动放在 JMH 的 @Setup(Level.Trial) 里:JMH 先完成初始化、拿到 ApplicationContext,再从容器取 Bean 执行 @Benchmark。如果先加载 Spring 再进入 JMH,容器上下文无法传给基准线程。
演示代码
@Slf4j
@State(Scope.Benchmark)
public class AppApplicationTest {
private final static Integer MEASUREMENT_ITERATIONS = 1;
private final static Integer WARMUP_ITERATIONS = 1;
// 初始化容器,通过 getBean 获取 Spring 管理的 bean
static ConfigurableApplicationContext context;
public String[] activeProfiles;
@Setup(Level.Trial)
public synchronized void initialize() {
try {
String args = "";
if (context == null) {
context = SpringApplication.run(AppApplication.class, args);
activeProfiles = context.getEnvironment().getActiveProfiles();
}
log.info("{}", activeProfiles);
} catch (Exception e) {
e.printStackTrace();
}
}
@Test
@Disabled
public void executeJmhRunner() throws RunnerException {
Options opt = new OptionsBuilder()
// 设置类名正则表达式,基准搜索当前类
.include("\\." + AppApplicationTest.class.getSimpleName() + "\\.")
// 参数可按需调整;较重的测试应放到服务器上跑
.warmupIterations(WARMUP_ITERATIONS) // 多少次预热
.measurementIterations(MEASUREMENT_ITERATIONS) // 要做多少次测量
.timeUnit(TimeUnit.MILLISECONDS) // 毫秒
// 不额外 fork 进程,测试与主进程运行在同一个 JVM,仅适合调试
.forks(0)
.threads(1) // 每个进程中的测试线程数
.mode(Mode.AverageTime)
.shouldDoGC(true)
.shouldFailOnError(true)
.resultFormat(ResultFormatType.JSON)
// .result("/dev/null") // set this to a valid filename if you want reports
.result("benchmark.json")
.jvmArgs("-server")
.build();
new Runner(opt).run();
}
@Benchmark
public void environment() {
}
}
控制台输出
容器在预热阶段启动,日志会挂在 -jmh-worker-1 线程下:
# JMH version: 1.21
# VM version: JDK 1.8.0_275, OpenJDK 64-Bit Server VM, 25.275-b01
# VM invoker: /Library/Java/JavaVirtualMachines/adoptopenjdk-8.jdk/Contents/Home/jre/bin/java
# VM options: -server
# Warmup: 1 iterations, 10 s each
# Measurement: 1 iterations, 10 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: cn.z201.jmh.AppApplicationTest.environment
# Run progress: 0.00% complete, ETA 00:00:20
# Fork: N/A, test runs in the host VM
# *** WARNING: Non-forked runs may silently omit JVM options, mess up profilers, disable compiler hints, etc. ***
# *** WARNING: Use non-forked runs only for debugging purposes, not for actual performance runs. ***
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.4.5)
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [StartupInfoLogger.java : 55] Starting application using Java 1.8.0_275 on z201MacBook-Pro.local with PID 23242 (started by qingfeng in /Users/qingfeng/word/code-example/SpringBoot-JMH)
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [SpringApplication.java : 679] The following profiles are active: dev
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [Bootstrap.java : 68] UT026010: Buffer pool was not set on WebSocketDeploymentInfo, the default pool will be used
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [ServletContextImpl.java : 371] Initializing Spring embedded WebApplicationContext
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [ServletWebServerApplicationContext.java : 289] Root WebApplicationContext: initialization completed in 809 ms
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [ExecutorConfigurationSupport.java : 181] Initializing ExecutorService 'applicationTaskExecutor'
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [Undertow.java : 120] starting server: Undertow - 2.2.7.Final
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [Xnio.java : 95] XNIO version 3.8.0.Final
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [NioXnio.java : 59] XNIO NIO Implementation Version 3.8.0.Final
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [Version.java : 52] JBoss Threads version 3.1.0.Final
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [UndertowWebServer.java : 133] Undertow started on port(s) 9031 (http)
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [StartupInfoLogger.java : 61] Started application in 2.018 seconds (JVM running for 3.629)
[cn.z201.jmh.AppApplicationTest.environment-jmh-worker-1] [AppApplicationTest.java : 40] dev
小结
JMH 靠 @Warmup 预热触发 JIT、@State 控制实例共享来保证结果可信;压测 List 写入时 CopyOnWriteArrayList 一万条耗时约 148 ms,只适合读多写少。接入 Spring Boot 时把 SpringApplication.run 放进 @Setup(Level.Trial),让容器先于基准方法启动。