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期連続の黒字決算。