JMH(Java Microbenchmark Harness)は、OpenJDK が作っている、Java の小さな処理の速さを正しく測るためのツールです。 System.nanoTime() で前後をはさむ素朴な計測では、JIT コンパイラ(実行中にコードを機械語に変える仕組み)の最適化で、数字が大きくずれます。

手元で System.nanoTime() で測ると、同じ処理なのに 1 回目は 15,039µs、2 回目以降は約 5,500µs、結果を使わないと 0µs になりました。JMH で測り直した結果が次の表です。

測り方 結果(JDK 21)
何もしないメソッド(baseline) 0.423 ns/op
計算して 結果を捨てる(wrong) 0.454 ns/op(計算が消えた)
計算して return する(right) 82.078 ns/op
計算して Blackhole に渡す 82.333 ns/op

結果を return するか Blackhole に渡す、入力は @State の final でないフィールドから読む、の2つを守るのが基本です。

確認環境:Ubuntu 24.04(2 vCPU の仮想マシン)、OpenJDK 21.0.10 と 25.0.4.1。JMH は GitHub の openjdk/jmh のタグ 1.37(2023年8月、執筆時点の最新タグ)のソースを javac でビルドし、依存の jopt-simple 5.0.4(GitHub のソース)と commons-math3 3.6.1(Ubuntu パッケージ)と組み合わせて動かしました。ほかの処理と CPU を共有する環境のため、誤差(± の値)は大きめです。Maven・Gradle の設定は JMH の README とアーキタイプ、jmh-gradle-plugin の README で確かめました(確認日 2026年10月13日)。

本記事の内容は、ご自由にお使いください。
ご利用の際は、出典として本ページへのリンクを記載いただけますようお願いします。

(記載例)出典:株式会社RJC「JMHの使い方|Javaマイクロベンチマークの正しい測り方」

System.nanoTime の素朴な計測で起きること

まず、JMH を使わずに測るとどうなるかを確かめます。1〜1,000 の2乗和を 10,000 回計算する時間を、同じプログラムの中で繰り返し測りました。

public class Naive {
    static long work(int n) {           // 測りたい処理(1〜n の2乗和)
        long r = 0;
        for (int i = 1; i <= n; i++) r += (long) i * i;
        return r;
    }

    public static void main(String[] args) {
        // 落とし穴1:ウォームアップ。同じ処理を8回測る
        for (int round = 1; round <= 8; round++) {
            long t0 = System.nanoTime();
            long sum = 0;
            for (int i = 0; i < 10_000; i++) sum += work(1_000 + (i & 7));
            long t1 = System.nanoTime();
            System.out.printf("round %d: %,7d us (sum=%d)%n", round, (t1 - t0) / 1_000, sum);
        }

        // 落とし穴2:結果を使わない。同じ処理なのに…
        for (int round = 1; round <= 5; round++) {
            long t0 = System.nanoTime();
            for (int i = 0; i < 10_000; i++) work(1_000 + (i & 7));   // 戻り値を捨てる
            long t1 = System.nanoTime();
            System.out.printf("unused %d: %,7d us%n", round, (t1 - t0) / 1_000);
        }
    }
}

JDK 21 での出力です。

round 1:  15,039 us (sum=3373545420000)
round 2:   5,629 us (sum=3373545420000)
round 3:   5,895 us (sum=3373545420000)
...
round 8:   3,600 us (sum=3373545420000)
unused 1:   3,576 us
unused 2:   3,588 us
unused 3:   8,008 us
unused 4:   4,438 us
unused 5:       0 us
起きたこと 原因
1回目だけ約3倍遅い(15,039µs → 約5,500µs) 最初はインタプリタで動き、途中から JIT が機械語にする(ウォームアップ)
結果を使わないと 0µs になった 結果が使われない計算を JIT が丸ごと消した(デッドコード除去)
途中で急に遅い回がある(8,008µs) JIT のコンパイルや GC、他のプロセスの影響

-Xint(JIT を止める)で動かすと、1回目が 166,137µs、2回目が 146,737µs で、ほぼ同じ遅さでした。最初が遅いのは JIT が動く前だからだと分かります。JDK 25 でも、1回目 13,241µs・2回目 5,767µs、結果を捨てると最後は 0µs と、同じ傾向でした。

素朴な計測の書き方は、関連記事「Java 処理時間の計測|nanoTimeとcurrentTimeMillis」で扱っています。アプリ全体の「どこが遅いか」を探すなら、関連記事「JFR(Java Flight Recorder)入門|記録とjfrコマンド分析」のプロファイラーが向いています。JMH は「この書き方とあの書き方、どちらが速いか」を小さく比べる道具です。

JMH の準備

Maven(公式の手順)

JMH の README が勧めているのは、Maven のアーキタイプ(ひな形)からプロジェクトを作る方法です。

mvn archetype:generate \
  -DinteractiveMode=false \
  -DarchetypeGroupId=org.openjdk.jmh \
  -DarchetypeArtifactId=jmh-java-benchmark-archetype \
  -DgroupId=org.sample \
  -DartifactId=test \
  -Dversion=1.0

cd test/
mvn clean verify
java -jar target/benchmarks.jar

できる pom.xml の要点は次のとおりです(アーキタイプのテンプレートより)。

<dependencies>
    <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>
</dependencies>
<!-- maven-shade-plugin で、Main-Class が org.openjdk.jmh.Main の benchmarks.jar を作る -->
jar 役割
jmh-core 実行する本体(org.openjdk.jmh.Main)
jmh-generator-annprocess @Benchmark から計測用のコードをコンパイル時に生成する
jopt-simple・commons-math3 jmh-core が使う(コマンド引数の解析と統計)

README には「IDE からの実行は、環境を管理できないので一般には勧めない」「Maven 以外のビルドスクリプトは JMH プロジェクトでは提供しない」とあります。Maven の基本は、関連記事「Mavenコマンド一覧|pom.xml書き方とよく使うオプション」で扱っています。

Gradle(jmh-gradle-plugin)

Gradle では、コミュニティのプラグイン me.champeau.jmh がよく使われます。README の例(Groovy DSL)をもとにした書き方です。

plugins {
    id 'java'
    id 'me.champeau.jmh' version '0.7.3'
}

jmh {
    jmhVersion = '1.37'
    warmupIterations = 3
    iterations = 5
    fork = 1
}

ベンチマークは src/jmh/java に置き、gradle jmh で動かします。結果は build/reports/jmh に出ます。

javac だけで動かす

ビルドツールを使わなくても、jar 4つをクラスパスに置けば動きました。ポイントは、注釈処理(annotation processing)で計測用のコードを生成させることです。

CP=jmh-core-1.37.jar:jopt-simple-5.0.4.jar:commons-math3-3.6.1.jar

javac -cp $CP \
      -processorpath jmh-generator-annprocess-1.37.jar:jmh-core-1.37.jar \
      -d classes $(find src -name '*.java')

java -cp classes:$CP org.openjdk.jmh.Main -l        # ベンチマークの一覧
java -cp classes:$CP org.openjdk.jmh.Main PitfallBench

コンパイルすると、ConcatBench_join_jmhTest.java のような生成コードと、ベンチマークの一覧ファイル META-INF/BenchmarkList ができました。注釈処理が動かないと BenchmarkList が作られず、実行時に次のエラーになります。

Exception in thread "main" java.lang.RuntimeException: ERROR: Unable to find the resource: /META-INF/BenchmarkList

注釈処理の jar を -processorpath ではなく -cp(クラスパス)に入れた場合は、JDK の版で結果が分かれました。

javac 注釈処理の jar を -cp に入れた場合
JDK 21 動いた(「将来は無効になるかもしれない」という Note が出た)
JDK 25 動かず、BenchmarkList が作られなかった(エラーも出ない)
JDK 25 + -proc:full 動いた

アーキタイプの pom は、jmh-generator-annprocess を provided の依存(クラスパス)として置く形です。JDK 25 でビルドするなら、maven-compiler-plugin で annotationProcessorPaths を指定するか、<proc>full</proc> を付ける形にすると、この差を避けられます。

最初のベンチマーク

冒頭の表の元になったコードです。

package com.example.bench;

import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
@Warmup(iterations = 3, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(1)
public class PitfallBench {

    double x = Math.PI;              // 入力は @State のフィールドから読む

    static double compute(double v) {    // 測りたい処理(小さな計算)
        double r = 0;
        for (int i = 1; i <= 50; i++) r += v / i;
        return r;
    }

    @Benchmark
    public void baseline() {          // 何もしない(測定の下限)
    }

    @Benchmark
    public void wrong() {             // NG:結果を捨てる → 計算ごと消えうる
        compute(x);
    }

    @Benchmark
    public double right() {           // OK:結果を return する
        return compute(x);
    }

    @Benchmark
    public void blackhole(Blackhole bh) {   // OK:複数の結果は Blackhole へ
        bh.consume(compute(x));
    }
}
Benchmark               Mode  Cnt   Score    Error  Units
PitfallBench.baseline   avgt    5   0.423 ±  0.206  ns/op
PitfallBench.blackhole  avgt    5  82.333 ± 18.711  ns/op
PitfallBench.right      avgt    5  82.078 ±  7.524  ns/op
PitfallBench.wrong      avgt    5   0.454 ±  0.222  ns/op

wrong は baseline とほぼ同じで、計算が消えています。 JDK 25 でも、baseline 0.407、wrong 0.748、right 70.799、blackhole 71.896 ns/op と同じ傾向でした。全体の実行時間は 33 秒でした。

結果の読み方

列 意味
Mode avgt=1回あたりの平均時間、thrpt=単位時間あたりの回数
Cnt 測定の回数(イテレーション数 × フォーク数)
Score 結果。avgt は小さいほど速い、thrpt は大きいほど速い
Error 99.9% 信頼区間の半分の幅。差が Error より小さいなら、差があるとは言えない
Units 単位。ns/op は1回あたりのナノ秒

詳しい出力には、(min, avg, max) = (80.240, 82.078, 84.145), stdev = 1.954 のような値も出ます。

落とし穴と JMH での対策

落とし穴 何が起きるか JMH での対策
ウォームアップ 最初の数回が遅い @Warmup の回数は結果に入れない
デッドコード除去 結果を使わない計算が消える return するか Blackhole.consume
定数畳み込み 入力が定数だと、計算が前もって済まされる 入力は @State の final でないフィールドから読む
ループの最適化 自分で書いたループがまとめて最適化される ループで回数を稼がず、JMH に回させる
実行順の影響 先に動かした処理の影響が残る @Fork で JVM を分けて動かす(既定 5)
準備の時間が混ざる データ作成の時間まで測る @Setup で準備する

定数畳み込み(JMH サンプル 10 を動かした結果)

JMH のソースに入っているサンプル JMHSample_10_ConstantFold を、そのまま動かしました。

private double x = Math.PI;
private final double wrongX = Math.PI;   // final にすると定数扱い

private double compute(double d) {
    for (int c = 0; c < 10; c++) {
        d = d * d / Math.PI;
    }
    return d;
}

@Benchmark public double measureWrong_1() { return compute(Math.PI); }  // 定数を直接
@Benchmark public double measureWrong_2() { return compute(wrongX); }   // final フィールド
@Benchmark public double measureRight()   { return compute(x); }        // 普通のフィールド
Benchmark                                 Mode  Cnt   Score   Error  Units
JMHSample_10_ConstantFold.baseline        avgt    5   0.856 ± 0.229  ns/op
JMHSample_10_ConstantFold.measureRight    avgt    5  14.876 ± 1.235  ns/op
JMHSample_10_ConstantFold.measureWrong_1  avgt    5   0.423 ± 0.187  ns/op
JMHSample_10_ConstantFold.measureWrong_2  avgt    5   0.427 ± 0.083  ns/op

final のフィールドを入力にすると、計算は 0.427ns になり、実質消えていました。 サンプルのコメントにも「IDE は final にできると言うだろうが、計測では従わないこと」と書かれています。

アノテーション一覧

アノテーション 意味 主な値
@Benchmark 測るメソッド ―
@BenchmarkMode 何を測るか Throughput(既定)・AverageTime・SampleTime・SingleShotTime・All
@OutputTimeUnit 結果の単位 TimeUnit.NANOSECONDS など
@State 入力や状態を持つクラス Scope.Thread・Scope.Benchmark・Scope.Group
@Setup / @TearDown 準備・後片付け Level.Trial・Level.Iteration・Level.Invocation
@Param 値を変えて同じベンチマークを動かす @Param({"10","100"})
@Warmup ウォームアップ iterations・time・timeUnit
@Measurement 本番の測定 iterations・time・timeUnit
@Fork JVM をいくつ起動して測るか value・jvmArgs・jvmArgsAppend
@Threads 同時に動かすスレッド数 1(既定)
@OperationsPerInvocation 1回の呼び出しで何回分の処理か ループを含むときの割り算
@CompilerControl JIT のインライン化などを制御 Mode.DONT_INLINE など

Scope.Thread はスレッドごとに別の State、Scope.Benchmark は全スレッドで共有です。Level.Invocation(呼び出しごとの準備)は、サンプル 07 のコメントに「時刻の記録と同期の処理が、測定値を大きくずらすことがある」と注意があります。

@Param で条件を変えて比べる

文字列の連結を、+=・StringBuilder・String.join で、要素数 10・100・1,000 について比べました。

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Benchmark)
@Warmup(iterations = 3, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(1)
public class ConcatBench {

    @Param({"10", "100", "1000"})
    int n;

    String[] words;

    @Setup(Level.Trial)
    public void setup() {             // 準備の時間は測定に入らない
        words = new String[n];
        for (int i = 0; i < n; i++) words[i] = "w" + i;
    }

    @Benchmark
    public String plusInLoop() {
        String s = "";
        for (String w : words) s += w;
        return s;
    }

    @Benchmark
    public String stringBuilder() {
        StringBuilder sb = new StringBuilder();
        for (String w : words) sb.append(w);
        return sb.toString();
    }

    @Benchmark
    public String join() {
        return String.join("", words);
    }
}
書き方 n=10 n=100 n=1,000
+=(ループ内) 0.147 ± 0.025 µs 3.809 ± 1.980 µs 356.828 ± 115.981 µs
StringBuilder 0.090 ± 0.075 µs 0.674 ± 0.507 µs 7.089 ± 2.250 µs
String.join 0.089 ± 0.055 µs 1.152 ± 0.557 µs 8.095 ± 2.628 µs

n=10 では差が Error の幅に収まり、はっきりした差とは言えません。n=1,000 では += が約50倍遅くなりました。 StringBuilder と join の差は、Error の幅の中です。実行時間は 1 分 17 秒でした。文字列連結の詳しい比較は、関連記事「Java StringBuilderの使い方|文字列連結の速度をJava 21で計測」で扱っています。

-prof gc でメモリの使用量も見る

-prof gc を付けると、1回あたりに確保したメモリ(gc.alloc.rate.norm)も出ます。n=1,000 の結果です。

java -cp classes:$CP org.openjdk.jmh.Main ConcatBench -p n=1000 -prof gc
書き方 時間(µs/op) 確保したメモリ(B/op) GC 回数
+= 320.183 1,940,922 112
StringBuilder 7.297 13,280 63
String.join 7.560 7,952 52

時間はほぼ同じでも、join は StringBuilder より確保したメモリが少ないことが分かりました。+= は1回の呼び出し(1,000回の連結)で約1.9MB を確保していました。GC の仕組みは、関連記事「Java ガベージコレクションの仕組みとGC種類比較|ログの読み方まで」で扱っています。

コマンドラインオプション一覧

java -jar benchmarks.jar -h(または org.openjdk.jmh.Main -h)で出る主なオプションです。@Measurement(iterations = 5) のベンチマークに -i 2 -wi 1 を付けると、Measurement: 2 iterations で動き、コマンドの指定が優先されました。

オプション 意味 既定値
正規表現 動かすベンチマークを名前で絞る 全部
-f <int> フォーク数(JVM の起動回数) 5
-wi <int> / -w <time> ウォームアップの回数 / 1回の時間 5 / 10 s
-i <int> / -r <time> 測定の回数 / 1回の時間 5 / 10 s
-bm <mode> モード(thrpt・avgt・sample・ss・all) Throughput
-tu <TU> 単位(s・ms・us・ns) SECONDS
-t <int> スレッド数 1
-p name=v1,v2 @Param の値を上書き ―
-prof <name> プロファイラー(gc・stack・jfr・comp など) ―
-rf json -rff out.json 結果をファイルに出す(text・csv・scsv・json・latex) ―
-jvmArgs "<args>" フォークした JVM に渡す JVM オプション ―
-l / -lprof ベンチマークの一覧 / 使えるプロファイラーの一覧 ―

既定値のまま動かすと、1つのベンチマークに「(5+5) × 10秒 × 5フォーク」で約8分かかります。 試すときは -f 1 -wi 3 -i 5 -w 1s -r 1s のように短くし、本番の比較は既定値に近い設定で動かす、という使い分けがあります。

-lprof では、Linux で perf が入っていないと perf・perfasm・perfnorm が「Unsupported」と表示されました。gc・stack・jfr・comp・cl・pauses・safepoints・mempool は「Supported」と表示されました。JDK 25 では、async-profiler を探す処理について WARNING: A restricted method in java.lang.System has been called が出ましたが、計測は動きました。

-rf json の結果には、jdkVersion・forks・params・primaryMetric.score などが入ります。CI で前回と比べるときに使えます。

よくある質問

Q. JMH の結果は、本番のアプリでの速さと同じですか。 A. 同じとは限りません。JMH は小さな処理を、JIT が十分に最適化した状態で測ります。本番ではデータの量・他の処理・GC の状況が違います。README にも「ベンチマークはレビューを受けるべき」「ハーネスが落とし穴を消してくれると思わないこと」とあります。

Q. -f 0(フォークしない)にしてもいいですか。 A. -h の説明には「フォークを無効にすると、ベンチマークと基盤の信頼性に悪い影響がありうる」とあります。使われるのは、IDE のデバッガーで中を追うときなどです。

Q. JVM オプション(ヒープサイズや GC)を変えて比べたいです。 A. @Fork(jvmArgsAppend = {"-Xmx1g"}) か、コマンドの -jvmArgs で渡します。JVM オプションの一覧は、関連記事「JVMオプション一覧|Xmx・Xms・GCログ設定をJava 21対応で」で扱っています。

Q. 出力の「Blackhole mode: compiler」とは何ですか。 A. JVM 側の機能を使う Blackhole(Compiler Blackholes)が、自動で選ばれたという表示です(JDK 21・25 とも compiler でした)。実行時には「JVM が試験的に対応している機能なので慎重に」「Blackhole のモードが違う結果どうしを比べないこと」という NOTE も表示されました。JVM をまたいで比べるときは、このモードも揃えます。

まとめ

  • System.nanoTime の素朴な計測は、1回目が約3倍遅く、結果を使わないと 0µs になった
  • JMH は @Benchmark を書き、注釈処理でコードを生成して 動かす。Maven はアーキタイプから
  • 結果は return か Blackhole、入力は final でない @State のフィールドから
  • Error の幅より小さい差は、差とは言えない
  • @Param で条件を変え、-prof gc でメモリの確保量も比べる
  • 試しは -f 1 -wi 3 -i 5 -w 1s -r 1s、既定のままだと1つ約8分

参考・出典

確認日はいずれも 2026年10月13日です。

  • OpenJDK「Code Tools: jmh」:https://openjdk.org/projects/code-tools/jmh/
  • GitHub openjdk/jmh(README・jmh-samples・アーキタイプ):https://github.com/openjdk/jmh
  • JMH サンプル(JMHSample_08_DeadCode・09_Blackholes・10_ConstantFold・11_Loops ほか):https://github.com/openjdk/jmh/tree/master/jmh-samples/src/main/java/org/openjdk/jmh/samples
  • jmh-gradle-plugin(me.champeau.jmh):https://github.com/melix/jmh-gradle-plugin

本記事の内容は、ご自由にお使いください。
ご利用の際は、出典として本ページへのリンクを記載いただけますようお願いします。

(記載例)出典:株式会社RJC「JMHの使い方|Javaマイクロベンチマークの正しい測り方」

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。

WE ARE HIRING

RJCで一緒に開発しながら、
成長を楽しみませんか?

RJCは、Web・モバイル・AIを活用した開発プロジェクトで、テックリードやPM・PMOも活躍するシステム開発会社です。会社を知る、待遇を確かめる、話を聞いてみる。気になるところ見てみてください!

  • 127日年間休日
  • 12時間平均残業時間
  • 毎日ガチャ遊びココロも大切にする福利厚生。アマギフなどの賞品ラインナップ!

ほかにも、チケットレストラン、書籍読み放題、2年ごとの慰労報奨(休暇 or 金一封)、11期連続の黒字決算。

ABOUT RJC RJCがどんな会社か知る 考え方、研修、働き方、福利厚生、社員の前職まで。RJCのことが丸わかり! RJC丸わかりページへ JOB DESCRIPTION 仕事内容・待遇を見てみる 仕事内容、給与・待遇、選考の流れ。経験者も未経験も!応募前に知りたいこと、まとめました! 募集要項を見る ENTRY エントリーする エントリーは1〜2分・履歴書不要です。まずは話を聞いてみたい、という方でも歓迎です! エントリーフォームへ

成長のヒミツ、 ぜんぶ丸わかり