写本文主要是简单记录一下JMH的使用方式。JMH全名是Java Microbenchmark Harness，主要为在jvm上运行的程序进行基准测试的工具。作为一个开发人员，在重构代码，或者确认功能的性能时，可以选中这个工具。
本文场景：代码重构，测试新代码和旧代码的性能区别（QPS）

准备工作

关键参数介绍

测试程序注解介绍

  • BenchmarkMode：基准模式
    • 参数：value
      • Mode.Throughput：单位时间吞吐量（ops）
      • Mode.AverageTime：每次操作的平均时间
      • Mode.SampleTime：采样每个操作的时间
      • Mode.SingleShotTime：测量一次操作的时间
      • Mode.All：把上述的都列出来
  • Warmup：预热。在测试代码运行前运行，主要防止 程序初始化 或 jvm运行一段时间后自动优化代码 产生的影响。
    • 参数如下：
      • iterations：运行次数，默认：-1
      • time：每次运行的时间，默认：-1
      • timeUnit：运行时间的单位，默认：秒
      • batchSize：批处理大小，每次操作调用几次方法，默认：-1
  • Measurement：具体测试参数。同 Warmup
  • Threads：每个进程中的测试线程，可用于类或者方法上。一般选择为cpu乘以2。如果配置了 Threads.MAX ，代表使用 Runtime.getRuntime().availableProcessors() 个线程。
  • Fork：
    • 参数如下：
      • value参数：多少个进程来测试，如果 fork 数是2的话，则 JMH 会 fork 出两个进程来进行测试
  • State：状态共享范围。
    • 参数如下：
      • Scope.Thread：不和其他线程共享
      • Scope.Group：相同类型的所有实例将在同一组内的所有线程之间共享。每个线程组将提供自己的状态对象
      • Scope.Benchmark：相同类型的所有实例将在所有工作线程之间共享
  • OutputTimeUnit：默认时间单位

程序执行输出内容介绍

  • Result内容介绍（因为测试的是 ops，单位是 秒，下面的结果都是基于 ops/s 来说）：
    • min：最小值
    • avg：平均值
    • max：最大值
    • stdev：标准差，对于平均值的分散程度（一般来讲越小越接近平均值）
  • 最终结果介绍：
    • Benchmark：jmh程序名
    • Mode：程序中设定的 BenchmarkMode
    • Cnt：总执行次数（不包含预热）
    • Score：格式是 结果是xxx ± xxx，单位时间内的结果，对本程序来说就是 ops/s
    • Error：
    • Units：单位

代码部分

程序介绍

  • 程序一：通过synchronized关键字实现的生产者消费者程序

  • 程序二：通过ReentrantLock实现的生产者消费者程序，将生产者消费者的队列区分开，减少不必要的争抢

    结果理论值

    程序二相比程序一来说，少了线程的争抢，吞吐量要高一些。

    具体程序

    2.   <properties>
    3.         <!-- 指定 jmh 版本号 -->
    4.       <version.jmh-core>1.25.2</version.jmh-core>
    5.       </properties>
    7.   <dependencies>
    8.       <!-- 引入 jmh -->
    9.       <dependency>
    10.           <groupId>org.openjdk.jmh</groupId>
    11.           <artifactId>jmh-core</artifactId>
    12.           <version>${version.jmh-core}</version>
    13.       </dependency>
    14.       <dependency>
    15.           <groupId>org.openjdk.jmh</groupId>
    16.           <artifactId>jmh-generator-annprocess</artifactId>
    17.           <version>${version.jmh-core}</version>
    18.       </dependency>
    19.   </dependencies>

    ```java /*

    • 被测试程序 1 */ package com.zhqy.juc.producerAndConsumer.jmh;

import org.slf4j.Logger; import org.slf4j.LoggerFactory;

import java.util.LinkedList;

/**

  • 通过 synchronized notify wait 关键字实现生产者、消费者工具

    *
  • @author wangshuaijing
  • @version 1.0.0

  • @date 2020/11/4 5:08 下午 */ public class SynchronizedVersion {

    private static final Logger LOGGER = LoggerFactory.getLogger(SynchronizedVersion.class);

    private static final int MAX = 20;

    private final LinkedList linkedList = new LinkedList<>();

    public synchronized void push(Object x) {

    1.  LOGGER.debug("生产者 - 进入对象锁 list数量：{}", linkedList.size());
    2.  while (linkedList.size() >= MAX) {
    3.      try {
    4.          LOGGER.debug("生产者 - 开始休眠 list数量：{}", linkedList.size());
    5.          wait();
    6.      } catch (InterruptedException e) {
    7.          e.printStackTrace();
    8.      }
    9.  }
    11.  // 将数据放入
    12.  linkedList.add(x);
    13.  LOGGER.debug("生产者 - 放入数据 {} 后 list数量：{}", x, linkedList.size());
    14.  notifyAll();

    }

    public synchronized Object pop() {

    1.  LOGGER.debug("消费者 - 进入对象锁 list数量：{}", linkedList.size());
    2.  while (linkedList.size() <= 0) {
    3.      try {
    4.          LOGGER.debug("消费者 - 开始休眠 list数量：{}", linkedList.size());
    5.          wait();
    6.      } catch (InterruptedException e) {
    7.          e.printStackTrace();
    8.      }
    9.  }
    11.  // 取出数据
    12.  Object last = linkedList.removeLast();
    13.  LOGGER.debug("消费者 - 消费 {}，list数量：{}", last, linkedList.size());
    14.  notifyAll();
    15.  return last;

    }

    }

    1. ```
    2. # 程序1 测试结果
    4. Result "com.zhqy.juc.producerAndConsumer.jmh.SynchronizedVersionTest.test":
    5.   36.339 ±(99.9%) 0.477 ops/s [Average]
    6.   (min, avg, max) = (31.214, 36.339, 44.255), stdev = 2.486
    7.   CI (99.9%): [35.862, 36.816] (assumes normal distribution)
    10. # Run complete. Total time: 00:53:56
    12. REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on
    13. why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial
    14. experiments, perform baseline and negative tests that provide experimental control, make sure
    15. the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts.
    16. Do not assume the numbers tell you what you want them to tell.
    18. Benchmark                                              Mode  Cnt   Score   Error  Units
    19. producerAndConsumer.jmh.SynchronizedVersionTest.test  thrpt  300  36.339 ± 0.477  ops/s
    1. /*
    2.  * 被测试程序 2
    3.  */
    4. package com.zhqy.juc.producerAndConsumer.jmh;
    6. import org.slf4j.Logger;
    7. import org.slf4j.LoggerFactory;
    9. import java.util.LinkedList;
    10. import java.util.concurrent.locks.Condition;
    11. import java.util.concurrent.locks.ReentrantLock;
    13. /**
    14.  * <h3>通过 可重入锁 实现生产者、消费者，生产者、消费者独立使用通知队列</h3>
    15.  *
    16.  * @author wangshuaijing
    17.  * @version 1.0.0
    18.  * @date 2020/11/4 5:08 下午
    19.  */
    20. public class ReentrantLockVersion {
    22.     private static final Logger LOGGER = LoggerFactory.getLogger(ReentrantLockVersion.class);
    24.     /**
    25.      * 容器中的最大数量
    26.      */
    27.     private static final int MAX = 20;
    29.     private final LinkedList<Object> linkedList = new LinkedList<>();
    31.     /**
    32.      * 定义一个 可重入锁
    33.      */
    34.     private final ReentrantLock reentrantLock = new ReentrantLock();
    35.     /**
    36.      * 为生产者定义一个独立的队列
    37.      */
    38.     private final Condition producerLock = reentrantLock.newCondition();
    39.     /**
    40.      * 为消费者定义一个独立的队列
    41.      */
    42.     private final Condition consumerLock = reentrantLock.newCondition();
    44.     public void push(Object x) {
    45.         try {
    46.             reentrantLock.lock();
    47.             LOGGER.debug("生产者 - 进入对象锁 list数量：{}", linkedList.size());
    49.             while (linkedList.size() >= MAX) {
    50.                 LOGGER.debug("生产者 - 开始休眠 list数量：{}", linkedList.size());
    51.                 producerLock.await();
    52.             }
    53.             linkedList.add(x);
    54.             LOGGER.debug("生产者 - 放入数据 {} 后 list数量：{}", x, linkedList.size());
    55.             consumerLock.signalAll();
    56.         } catch (InterruptedException e) {
    57.             e.printStackTrace();
    58.         } finally {
    59.             reentrantLock.unlock();
    60.         }
    61.     }
    63.     public Object pop() {
    64.         try {
    65.             reentrantLock.lock();
    66.             LOGGER.debug("消费者 - 进入对象锁 list数量：{}", linkedList.size());
    68.             while (linkedList.size() <= 0) {
    69.                 LOGGER.debug("消费者 - 开始休眠 list数量：{}", linkedList.size());
    70.                 consumerLock.await();
    71.             }
    72.             Object last = linkedList.removeLast();
    73.             LOGGER.debug("消费者 - 消费 {}，list数量：{}", last, linkedList.size());
    74.             producerLock.signalAll();
    75.             return last;
    76.         } catch (InterruptedException e) {
    77.             e.printStackTrace();
    78.             return null;
    79.         } finally {
    80.             reentrantLock.unlock();
    81.         }
    82.     }
    84. }
    1. # 程序2测试结果
    3. Result "com.zhqy.juc.producerAndConsumer.jmh.ReentrantLockVersionTest.test":
    4.   39.203 ±(99.9%) 0.282 ops/s [Average]
    5.   (min, avg, max) = (35.262, 39.203, 44.288), stdev = 1.472
    6.   CI (99.9%): [38.921, 39.486] (assumes normal distribution)
    9. # Run complete. Total time: 00:53:51
    11. REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on
    12. why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial
    13. experiments, perform baseline and negative tests that provide experimental control, make sure
    14. the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts.
    15. Do not assume the numbers tell you what you want them to tell.
    17. Benchmark                                               Mode  Cnt   Score   Error  Units
    18. producerAndConsumer.jmh.ReentrantLockVersionTest.test  thrpt  300  39.203 ± 0.282  ops/s

    最终结果

    • 与理论值相同，程序二（通过ReentrantLock，分开生产者、消费者队列）降低了不必要的线程的争抢，增加了最终的吞吐量。
    • jmh还可以用来排查并发问题 ^_^