2. 程式人生 > >Java微基準測試框架JMH

Java微基準測試框架JMH

阿新 • • 發佈：2019-01-02

本文轉自：https://www.xncoding.com/2018/01/07/java/jmh.html 

作者：XiongNeng

JMH，即Java Microbenchmark Harness，這是專門用於進行程式碼的微基準測試的一套工具API。

JMH 由 OpenJDK/Oracle 裡面那群開發了 Java 編譯器的大牛們所開發 。何謂 Micro Benchmark 呢？ 簡單地說就是在 method 層面上的 benchmark，精度可以精確到微秒級。

Java的基準測試需要注意的幾個點：

  • 測試前需要預熱。

  • 防止無用程式碼進入測試方法中。

  • 併發測試。

  • 測試結果呈現。

比較典型的使用場景：

  1. 當你已經找出了熱點函式，而需要對熱點函式進行進一步的優化時，就可以使用 JMH 對優化的效果進行定量的分析。

  2. 想定量地知道某個函式需要執行多長時間，以及執行時間和輸入 n 的相關性

  3. 一個函式有兩種不同實現（例如JSON序列化/反序列化有Jackson和Gson實現），不知道哪種實現效能更好

儘管 JMH 是一個相當不錯的 Micro Benchmark Framework，但很無奈的是網上能夠找到的文件比較少，而官方也沒有提供比較詳細的文件，對使用造成了一定的障礙。 但是有個好訊息是官方的 Code Sample 寫得非常淺顯易懂， 推薦在需要詳細瞭解 JMH 的用法時可以通讀一遍——本文則會介紹 JMH 最典型的用法和部分常用選項。

第一個例子

新增maven依賴

如果使用maven專案，只需要新增如下依賴：

 <!-- JMH-->
 <dependency>
     <groupId>org.openjdk.jmh</groupId>
     <artifactId>jmh-core</artifactId>
     <version>${jmh.version}</version>
 </dependency>
 <dependency>
     <groupId>org.openjdk.jmh</groupId>
     <artifactId>jmh-generator-annprocess</artifactId>
     <version>${jmh.version}</version>
     <scope>provided</scope>
 </dependency>

編寫效能測試

接下來我寫一個比較字串連線操作的時候，直接使用字串相加和使用StringBuilder的append方式的效能比較測試：

 /**
  * 比較字串直接相加和StringBuilder的效率
  */
 @BenchmarkMode(Mode.Throughput)
 @Warmup(iterations = 3)
 @Measurement(iterations = 10, time = 5, timeUnit = TimeUnit.SECONDS)
 @Threads(8)
 @Fork(2)
 @OutputTimeUnit(TimeUnit.MILLISECONDS)
 public class StringBuilderBenchmark {
 
     @Benchmark
     public void testStringAdd() {
         String a = "";
         for (int i = 0; i < 10; i++) {
             a += i;
         }
         print(a);
     }

     @Benchmark
     public void testStringBuilderAdd() {
         StringBuilder sb = new StringBuilder();
         for (int i = 0; i < 10; i++) {
             sb.append(i);
         }
         print(sb.toString());
     }

     private void print(String a) {
     }
 }

執行方式

這個程式碼裡面有好多註解，你第一次見可能不知道什麼意思。先不用管，我待會一一介紹。

我們來執行這個測試，執行JMH基準測試有多種方式，一個是生成jar檔案執行， 一個是直接寫main函式或寫單元測試執行。

一般對於大型的測試，需要測試時間比較久，執行緒比較多的話，就需要去寫好了丟到linux程式裡執行， 不然本機執行很久時間什麼都幹不了了。

mvn clean package
java -jar target/benchmarks.jar

先編譯打包之後，然後執行就可以了。當然在執行的時候可以輸入-h引數來看幫助。

另外如果對於一些小的測試，比如我寫的上面這個小例子，在IDE裡面就可以完成了，丟到linux上去太麻煩。 這時候可以在裡面新增一個main函式如下：

public static void main(String[] args) throws RunnerException {
    Options options = new OptionsBuilder()
            .include(StringBuilderBenchmark.class.getSimpleName())
            .output("E:/Benchmark.log")
            .build();
    new Runner(options).run();
}

這裡其實也比較簡單，new個Options，然後傳入要執行哪個測試，選擇基準測試報告輸出檔案地址，然後通過Runner的run方法就可以跑起來了。

報告結果

我們跑一下這個基準測試，完成後開啟E:/Benchmark.log，結果如下：

 # JMH version: 1.20
 # VM version: JDK 1.8.0_131, VM 25.131-b11
 # VM invoker: C:\Program Files\Java\jdk1.8.0_131\jre\bin\java.exe
 # VM options: -javaagent:E:\Program Files\JetBrains\IntelliJ IDEA 2017.3\lib\idea_rt.jar=62744:E:\Program Files\JetBrains\IntelliJ IDEA 2017.3\bin -Dfile.encoding=UTF-8
 # Warmup: 3 iterations, 1 s each
 # Measurement: 10 iterations, 5 s each
 # Timeout: 10 min per iteration
 # Threads: 16 threads, will synchronize iterations
 # Benchmark mode: Throughput, ops/time
 # Benchmark: com.xncoding.benchmark.string.StringBuilderBenchmark.testStringAdd
 
 # Run progress: 0.00% complete, ETA 00:03:32
 # Fork: 1 of 2
 # Warmup Iteration   1: 7332.410 ops/ms
 # Warmup Iteration   2: 8758.506 ops/ms
 # Warmup Iteration   3: 9078.783 ops/ms
 Iteration   1: 8824.713 ops/ms
 Iteration   2: 9084.977 ops/ms
 Iteration   3: 9412.712 ops/ms
 Iteration   4: 8843.631 ops/ms
 Iteration   5: 9030.556 ops/ms
 Iteration   6: 9090.677 ops/ms
 Iteration   7: 9493.148 ops/ms
 Iteration   8: 8664.593 ops/ms
 Iteration   9: 8835.227 ops/ms
 Iteration  10: 8570.212 ops/ms
 
 # Run progress: 25.00% complete, ETA 00:03:15
 # Fork: 2 of 2
 # Warmup Iteration   1: 5350.686 ops/ms
 # Warmup Iteration   2: 8862.238 ops/ms
 # Warmup Iteration   3: 8086.594 ops/ms
 Iteration   1: 9105.306 ops/ms
 Iteration   2: 8288.588 ops/ms
 Iteration   3: 9307.902 ops/ms
 Iteration   4: 9195.150 ops/ms
 Iteration   5: 8715.555 ops/ms
 Iteration   6: 9075.069 ops/ms
 Iteration   7: 9041.037 ops/ms
 Iteration   8: 9187.099 ops/ms
 Iteration   9: 9145.134 ops/ms
 Iteration  10: 9124.229 ops/ms
 
 
 Result "com.xncoding.benchmark.string.StringBuilderBenchmark.testStringAdd":
   9001.776 ±(99.9%) 253.496 ops/ms [Average]
   (min, avg, max) = (8288.588, 9001.776, 9493.148), stdev = 291.926
   CI (99.9%): [8748.280, 9255.272] (assumes normal distribution)
 
 
 # JMH version: 1.20
 # VM version: JDK 1.8.0_131, VM 25.131-b11
 # VM invoker: C:\Program Files\Java\jdk1.8.0_131\jre\bin\java.exe
 # VM options: -javaagent:E:\Program Files\JetBrains\IntelliJ IDEA 2017.3\lib\idea_rt.jar=62744:E:\Program Files\JetBrains\IntelliJ IDEA 2017.3\bin -Dfile.encoding=UTF-8
 # Warmup: 3 iterations, 1 s each
 # Measurement: 10 iterations, 5 s each
 # Timeout: 10 min per iteration
 # Threads: 16 threads, will synchronize iterations
 # Benchmark mode: Throughput, ops/time
 # Benchmark: com.xncoding.benchmark.string.StringBuilderBenchmark.testStringBuilderAdd
 
 # Run progress: 50.00% complete, ETA 00:02:07
 # Fork: 1 of 2
 # Warmup Iteration   1: 27202.528 ops/ms
 # Warmup Iteration   2: 26500.586 ops/ms
 # Warmup Iteration   3: 27190.346 ops/ms
 Iteration   1: 27891.257 ops/ms
 Iteration   2: 28704.541 ops/ms
 Iteration   3: 27785.951 ops/ms
 Iteration   4: 26841.454 ops/ms
 Iteration   5: 26024.288 ops/ms
 Iteration   6: 25592.494 ops/ms
 Iteration   7: 25626.875 ops/ms
 Iteration   8: 25302.248 ops/ms
 Iteration   9: 25519.780 ops/ms
 Iteration  10: 25275.334 ops/ms
 
 # Run progress: 75.00% complete, ETA 00:01:02
 79# Fork: 2 of 2
 # Warmup Iteration   1: 30376.008 ops/ms
 # Warmup Iteration   2: 25131.064 ops/ms
 # Warmup Iteration   3: 25622.342 ops/ms
 Iteration   1: 25386.845 ops/ms
 Iteration   2: 25825.139 ops/ms
 Iteration   3: 26029.607 ops/ms
 Iteration   4: 25531.748 ops/ms
 Iteration   5: 25374.934 ops/ms
 Iteration   6: 25204.530 ops/ms
 Iteration   7: 22934.211 ops/ms
 Iteration   8: 23907.677 ops/ms
 Iteration   9: 24337.963 ops/ms
 Iteration  10: 24660.626 ops/ms
 
 
 Result "com.xncoding.benchmark.string.StringBuilderBenchmark.testStringBuilderAdd":
   25687.875 ±(99.9%) 1167.955 ops/ms [Average]
   (min, avg, max) = (22934.211, 25687.875, 28704.541), stdev = 1345.019
   CI (99.9%): [24519.920, 26855.830] (assumes normal distribution)
 

 # Run complete. Total time: 00:04:08

 Benchmark                                     Mode  Cnt      Score      Error   Units
 StringBuilderBenchmark.testStringAdd         thrpt   20   9001.776 ±  253.496  ops/ms
 StringBuilderBenchmark.testStringBuilderAdd  thrpt   20  25687.875 ± 1167.955  ops/ms

仔細看，三大部分，第一部分是字串用加號連線執行的結果，第二部分是StringBuilder執行的結果，第三部分就是兩個的簡單結果比較。這裡注意我們forks傳的2，所以每個測試有兩個fork結果。

前兩部分是一樣的，簡單說下。首先會寫出每部分的一些引數設定，然後是預熱迭代執行（Warmup Iteration）， 然後是正常的迭代執行（Iteration），最後是結果（Result）。這些看看就好，我們最關注的就是第三部分， 其實也就是最終的結論。千萬別看歪了，他輸出的也確實很不爽，error那列其實沒有內容，score的結果是xxx ± xxx，單位是每毫秒多少個操作。可以看到，StringBuilder的速度還確實是要比String進行文字疊加的效率好太多。

註解介紹

好了，當你對JMH有了一個基本認識後，現在來詳細解釋一下前面程式碼中的各個註解含義。

@BenchmarkMode

基準測試型別。這裡選擇的是Throughput也就是吞吐量。根據原始碼點進去，每種型別後面都有對應的解釋，比較好理解，吞吐量會得到單位時間內可以進行的運算元。

  • Throughput: 整體吞吐量，例如“1秒內可以執行多少次呼叫”。

  • AverageTime: 呼叫的平均時間，例如“每次呼叫平均耗時xxx毫秒”。

  • SampleTime: 隨機取樣，最後輸出取樣結果的分佈，例如“99%的呼叫在xxx毫秒以內，99.99%的呼叫在xxx毫秒以內”

  • SingleShotTime: 以上模式都是預設一次 iteration 是 1s，唯有 SingleShotTime 是隻執行一次。往往同時把 warmup 次數設為0，用於測試冷啟動時的效能。

  • All(“all”, “All benchmark modes”);

@Warmup

上面我們提到了，進行基準測試前需要進行預熱。一般我們前幾次進行程式測試的時候都會比較慢， 所以要讓程式進行幾輪預熱，保證測試的準確性。其中的引數iterations也就非常好理解了，就是預熱輪數。

為什麼需要預熱？因為 JVM 的 JIT 機制的存在，如果某個函式被呼叫多次之後，JVM 會嘗試將其編譯成為機器碼從而提高執行速度。所以為了讓 benchmark 的結果更加接近真實情況就需要進行預熱。

@Measurement

度量，其實就是一些基本的測試引數。

  1. iterations 進行測試的輪次

  2. time 每輪進行的時長

  3. timeUnit 時長單位

都是一些基本的引數，可以根據具體情況調整。一般比較重的東西可以進行大量的測試，放到伺服器上執行。

@Threads

每個程序中的測試執行緒，這個非常好理解，根據具體情況選擇，一般為cpu乘以2。

@Fork

進行 fork 的次數。如果 fork 數是2的話，則 JMH 會 fork 出兩個程序來進行測試。

@OutputTimeUnit

這個比較簡單了，基準測試結果的時間型別。一般選擇秒、毫秒、微秒。

@Benchmark

方法級註解，表示該方法是需要進行 benchmark 的物件，用法和 JUnit 的 @Test 類似。

@Param

屬性級註解，@Param 可以用來指定某項引數的多種情況。特別適合用來測試一個函式在不同的引數輸入的情況下的效能。

@Setup

方法級註解，這個註解的作用就是我們需要在測試之前進行一些準備工作，比如對一些資料的初始化之類的。

@TearDown

方法級註解，這個註解的作用就是我們需要在測試之後進行一些結束工作，比如關閉執行緒池，資料庫連線等的，主要用於資源的回收等。

@State

當使用@Setup引數的時候，必須在類上加這個引數，不然會提示無法執行。

State 用於宣告某個類是一個“狀態”，然後接受一個 Scope 引數用來表示該狀態的共享範圍。 因為很多 benchmark 會需要一些表示狀態的類，JMH 允許你把這些類以依賴注入的方式注入到 benchmark 函式裡。Scope 主要分為三種。

  1. Thread: 該狀態為每個執行緒獨享。

  2. Group: 該狀態為同一個組裡面所有執行緒共享。

  3. Benchmark: 該狀態在所有執行緒間共享。

關於State的用法，官方的 code sample 裡有比較好的例子。

第二個例子

再來看一個更常規一點效能測試的例子，

計算 1 ~ n 之和，比較序列演算法和並行演算法的效率，看 n 在大約多少時並行演算法開始超越序列演算法

首先定義一個表示這兩種實現的介面：

/**
 * Calculator
 *
 * @author XiongNeng
 * @version 1.0
 * @since 2018/1/7
 */
public interface Calculator {
    /**
     * calculate sum of an integer array
     *
     * @param numbers
     * @return
     */
    public long sum(int[] numbers);

    /**
     * shutdown pool or reclaim any related resources
     */
    public void shutdown();
}

具體的兩種實現程式碼我就不貼了，主要說明一下序列演算法和並行演算法實現原理：

  • 序列演算法：使用 for-loop 來計算 n 個正整數之和。

  • 並行演算法：將所需要計算的 n 個正整數分成 m 份，交給 m 個執行緒分別計算出和以後，再把它們的結果相加。

進行 benchmark 的程式碼如下：

/**
 * 自然數求和的序列和並行演算法效能測試
 *
 * @author XiongNeng
 * @version 1.0
 * @since 2018/1/7
 */
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Benchmark)
public class SecondBenchmark {
    @Param({"10000", "100000", "1000000"})
    private int length;

    private int[] numbers;
    private Calculator singleThreadCalc;
    private Calculator multiThreadCalc;

    public static void main(String[] args) throws Exception {
        Options opt = new OptionsBuilder()
                .include(SecondBenchmark.class.getSimpleName())
                .forks(1)
                .warmupIterations(5)
                .measurementIterations(2)                .build();
        Collection<RunResult> results =  new Runner(opt).run();
        ResultExporter.exportResult("單執行緒與多執行緒求和效能", results, "length", "微秒");
    }

    @Benchmark
    public long singleThreadBench() {
        return singleThreadCalc.sum(numbers);
    }

    @Benchmark
    public long multiThreadBench() {
        return multiThreadCalc.sum(numbers);
    }

    @Setup
    public void prepare() {
        numbers = IntStream.rangeClosed(1, length).toArray();
        singleThreadCalc = new SinglethreadCalculator();
        multiThreadCalc = new MultithreadCalculator(Runtime.getRuntime().availableProcessors());
    }

    @TearDown
    public void shutdown() {
        singleThreadCalc.shutdown();
        multiThreadCalc.shutdown();
    }
}

我在自己的膝上型電腦上跑下來的結果，總數在10000時並行演算法不如序列演算法， 總數達到100000時並行演算法開始和序列演算法接近，總數達到1000000時並行演算法所耗時間約是序列演算法的一半左右。

 

參考文章

  • Java使用JMH進行簡單的基準測試Benchmark

  • Java 併發程式設計筆記：JMH 效能測試框架

  • JMH - Java Microbenchmark Harness

相關推薦

Java微基準測試框架JMH

本文轉自：https://www.xncoding.com/2018/01/07/java/jmh.html  作者：XiongNeng JMH，即Java Microbenchmark Harness，這是專門用於進行程式碼的微基準測試的一套工具API。 JM

java 性能測試框架工具-junitperf

mas lang 1.7 ogr art 技術分享 hello 圖片 success 性能測試工具 對於 Java 開發者來說，要去學習性能測試工具未免很麻煩。 但有時候會有性能測試的需求。 junitperf junitperf 就是一款為 Java 開發者設計的性能測試

TestNg JAVA 自動化單元測試框架Demo

環境準備 既然是java 的自動化單元測試框架，就必須要有java的環境了，這裡使用的編輯器是Eclipse,已經安裝過TestNg 外掛，如果環境準備好就可以開始了 程式碼例項 程式碼結構

Java JUnit 單元測試框架。

JUnit是一個Java語言的單元測試框架。 Junit 測試也是程式設計師測試，即所謂的白盒測試 如使用eclipse 開發，不用新增jar包，eclipse內部已經集成了，我們只需要引入即可使用。 1.新增方法，【專案】上右擊，選擇Build Path ,進入 2 .

Java mocking 單元測試框架介紹

我需要在資料庫裡插入一些資料，基於這些真實的資料我才可以進行單元測試，而且每次都需要重複準備指令碼，還要考慮資料的清理。 我需要啟動一個Tomcat，然後通過Http Client傳送請求，然後觀察資料，才可以進行測試。 我需要啟動Dubbo服務的提供者，因

一文了解十大 Java 開發者必備測試框架！

Java介面自動化測試框架設計-2-Get請求方法和測試

      這篇開始，我來介紹通過程式碼逐步實現介面自動化測試框架的設計過程。先不要著急，框架設計我們只是介紹基本的元件，而且框架設計沒有想象那麼難，一步一步跟著做就會了。這篇我們來演示，如果通過Java程式碼來實現一個用純程式碼實現Http中的Get請求過程。1.Get請求

Java介面自動化測試框架設計-4-POST請求方法封裝過程和測試

       這個介面自動化測試框架到目前為止，我們已經完成了Get請求的封裝和必要的工具類的支援。接下來這篇，我來介紹如何完成POST請求的封裝過程。一般來說，在一個專案中，介面測試很多時候就是測試Get和POST方法，其他的請求方式的介面很少，佔的比重幾乎不計。所以，這個

基於C#的機器學習--微基準測試和啟用功能

本章我們將學習以下內容: l  什麼是微基準測試 l  如何將它應用到程式碼中 l  什麼是啟用函式 l  如何繪製和基準測試啟用函式 每個開發人員都需要有一個好的基準測試工具。質量基準無處不在;你們每天都能聽到，這個減少了10%那個增加了25%還記得那句老話

【基準測試】JMH 簡單入門

JMH 簡單入門 什麼是 JMH JMH 是 Java Microbenchmark Harness 的縮寫。中文意思大致是 “JAVA 微基準測試套件”。首先先明白什麼是“基準測試”。百度百科給的定義如下： 基準測試是指通過設計科學的測試方法、測試工具和測試系統，實現對一類測試物件的某項效能指標進行

Selenium 4 Java的最佳測試框架

幾十年來，Java一直是開發應用程式伺服器端的首選程式語言。儘管JUnit一直在與開發人員一起幫助他們進行自動化的單元測試，但隨著時間的推移和測試行業的發展，特別是伴隨著自動化測試的興起，已經開發了許多基於Java的開源框架，它們在驗證和業務邏輯方面與JUnit有所不同。在這裡，我將討論用於使用Seleniu

Java+Maven+selenium+testing+reportNG自動化測試框架

都是 tlist image pub tro snapshot htm sea cells 最近公司新出了一個產品，需要搭建自動化測試框架，這是一個學以至用的好機會，跟上級申請後，決定搭建一個java自動化測試框架。 Java自動化測試對我來講可以說不難不易，因為java是

java實現沙箱測試環境支付寶支付（demo）和整合微信支付和支付寶支付到ssm

mar 文件 fun Go examples IT === throws 由於 文章有不當之處，歡迎指正，如果喜歡微信閱讀，你也可以關註我的微信公眾號：好好學java，獲取優質學習資源。 一、支付寶測試環境代碼測試 1.下載電腦網站的官方demo： 下載地址：https:

【外掛釋出】JAVA微服務框架，Jeecg-P3-Demo 1.0.0 外掛開源釋出

JAVA微服務框架，Jeecg-P3-Demo 1.0.0 外掛開源釋出 Jeecg-P3-Demo專案，採用JEECG-P3微服務框架技術，做了幾個常見Demo功能案例：普通列表、樹列表、一對多列表、產品管理（bootstrap-talbe列表）等功能，為大家快速瞭解使用P3微服務

微信公眾賬號第三方平臺全網釋出原始碼（java）- 實戰測試通過

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Oracle釋出開源的輕量級 Java 微服務框架 Helidon

近日，Oracle推出了一個新的開源框架Helidon，該專案是一個用於建立基於微服務的應用程式的Java庫集合。和Payara Micro、Thorntail（之前的WildFly Swarm）、OpenLiberty、TomEE等專案一樣，該專案也加入了MicroProfile家族。 Helidon最初

Java&Selenium Web自動化測試框架理念

一、自動化測試含義 在自動化測試領域內流傳著一個說法：單元測試才是自動化測試的核心，在自動化測試裡，無論框架何等完美都不可能脫離單元測試，單元測試將會是自動化測試裡最小的單位，把它看作單位一，若干個單位一組成了一個整體，它就成了自動化測試； 諸如Python的單元測試框架Unittest、Pytest；J

Android自動化測試實戰(Java篇+主流工具+框架+指令碼)

第1章 課程簡介 我們為什麼要學自動化測試？如果你現在開啟一家招聘網站，輸入自動化測試，不難發現，自動化測試已經成為了軟體測試領域的大趨勢，測試人員能力的分水嶺，高薪福利的必爭地。但每個公司招聘要求中，技能點要求那麼多，我們如何進行系統的學習，成為一名合格的自動化測試工程師呢？ 在這門課程將... 1-1 課

NutzWk 5.1.2 釋出，Java 微服務分散式開發框架

   NutzWk 5.1.2 更新內容： 增加微服務異常時的友好錯誤提示； 增加Web服務的500錯誤頁面配置； 增加對不支援的IE版本友好提示； 修復Result類一個方法預設值為空的問題； 完善程式碼生成器，支援Vue版本程式碼生成 (IDEA官方外掛庫搜 w

使用 JMH 做 Kotlin 的基準測試

一. 基準測試 基準測試是指通過設計科學的測試方法、測試工具和測試系統，實現對一類測試物件的某項效能指標進行定量的和可對比的測試。 基準測試是一種測量和評估軟體效能指標的活動。你可以在某個時候通過基準測試建立一個已知的效能水平（稱為基準線），當系統的軟硬體環境發生變化之後再進行