Java JMH常见的基准测试场景代码实例解读

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

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
import java.util.concurrent.TimeUnit;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

@BenchmarkMode(Mode.AverageTime) // 测试模式：平均执行时间
@OutputTimeUnit(TimeUnit.NANOSECONDS) // 输出时间单位
@Warmup(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS) // 预热：3轮，每轮1秒
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) // 测试：5轮，每轮1秒
@Fork(1) // 使用1个进程
@State(Scope.Benchmark) // 状态共享范围
public class JMHExampleBenchmark {

    // 测试参数：可以用@Param注解测试不同参数值的影响
    @Param({"10", "100", "1000"})
    public int size;

    private List<Integer> arrayList;
    private List<Integer> linkedList;
    private int[] array;
    private AtomicInteger atomicCounter;
    private ConcurrentHashMap<Integer, Integer> concurrentMap;
    private Random random;

    // 初始化方法，在每个测试前执行
    @Setup
    public void setup() {
        arrayList = new ArrayList<>(size);
        linkedList = new LinkedList<>();
        array = new int[size];
        atomicCounter = new AtomicInteger(0);
        concurrentMap = new ConcurrentHashMap<>();
        random = new Random();

        for (int i = 0; i < size; i++) {
            arrayList.add(i);
            linkedList.add(i);
            array[i] = i;
            concurrentMap.put(i, i);
        }
    }

    // 场景1：ArrayList vs LinkedList 随机访问性能对比
    @Benchmark
    public void arrayListRandomAccess(Blackhole bh) {
        for (int i = 0; i < size; i++) {
            bh.consume(arrayList.get(random.nextInt(size)));
        }
    }

    @Benchmark
    public void linkedListRandomAccess(Blackhole bh) {
        for (int i = 0; i < size; i++) {
            bh.consume(linkedList.get(random.nextInt(size)));
        }
    }

    // 场景2：数组遍历的不同方式性能对比
    @Benchmark
    public int arrayTraversalForLoop() {
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        return sum;
    }

    @Benchmark
    public int arrayTraversalForEach() {
        int sum = 0;
        for (int value : array) {
            sum += value;
        }
        return sum;
    }

    // 场景3：字符串拼接方式性能对比
    @Benchmark
    public String stringConcatPlus() {
        String result = "";
        for (int i = 0; i < size; i++) {
            result += i;
        }
        return result;
    }

    @Benchmark
    public String stringConcatBuilder() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < size; i++) {
            sb.append(i);
        }
        return sb.toString();
    }

    // 场景4：原子操作性能测试
    @Benchmark
    public void atomicIncrement() {
        atomicCounter.incrementAndGet();
    }

    // 场景5：并发Map操作测试
    @Benchmark
    public void concurrentMapPut() {
        int key = random.nextInt(size);
        concurrentMap.put(key, key);
    }

    @Benchmark
    public void concurrentMapGet(Blackhole bh) {
        int key = random.nextInt(size);
        bh.consume(concurrentMap.get(key));
    }

    // 场景6：多线程测试
    @Benchmark
    @Threads(4) // 使用4个线程
    public void multiThreadedIncrement() {
        atomicCounter.incrementAndGet();
    }

    // 场景7：吞吐量测试模式
    @Benchmark
    @BenchmarkMode(Mode.Throughput) // 测试吞吐量(ops/time)
    @OutputTimeUnit(TimeUnit.SECONDS)
    public void throughputTest() {
        // 简单的数学运算
        double result = Math.sin(random.nextDouble()) * Math.cos(random.nextDouble());
        Blackhole.consumeCPU(100); // 模拟一些CPU工作
    }

    // 场景8：测试模式组合
    @Benchmark
    @BenchmarkMode({Mode.AverageTime, Mode.Throughput})
    public void multiModeTest() {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        Blackhole.consumeCPU(50);
    }
}

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;

public class JMHRunner {
    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(JMHExampleBenchmark.class.getSimpleName())
                .forks(1) // 使用1个进程
                .build();

        new Runner(opt).run();
    }
}

Benchmark                                  (size)   Mode  Cnt      Score      Error  Units
JMHExample.arrayListRandomAccess             100  avgt    5   1234.567 ±   12.345  ns/op
JMHExample.linkedListRandomAccess            100  avgt    5  56789.012 ±  678.901  ns/op
JMHExample.stringConcatPlus                  100  avgt    5  12345.678 ±  123.456  ns/op
JMHExample.stringConcatBuilder               100  avgt    5    123.456 ±    1.234  ns/op
JMHExample.throughputTest                    N/A  thrpt    5  123456.789 ± 1234.567  ops/s