メインコンテンツへスキップ
見出し画像

Java 25・GraalVM native・Go 1.27、あなたはどれを選ぶ? ── 速さ・起動・メモリを実測して考えた、クラウドネイティブとAI時代の選び方

    新しくサービスを作るとき、Java で書くか、Java を GraalVM で事前コンパイルするか、それとも Go にするか。 「Java は遅い」「Go は速い」「GraalVM の native-image を使えば Java も Go のように速く起動できる」といった話はよく聞きますが、クラウドネイティブや AI と一緒にコードを書くことが当たり前になった今、選ぶ基準そのものが変わってきていると感じています。

    そこで判断材料を集めるために、同じ処理を Java と Go で書き、次の 3 つを実測で比べてみました。

    • Java 25:いわゆる普通の Java。実行しながら最適化する(JIT コンパイル)

    • GraalVM native:同じ Java のコードを、事前に機械語へコンパイルして単体の実行ファイルにしたもの(AOT コンパイル)

    • Go 1.27:最初から事前コンパイルが前提の言語

    GraalVM native は、いわば「Java で書いて、Go のように配る」ための技術です。 この記事では、Java 25 と GraalVM native を「同じコードの 2 つの動かし方」として比べ、さらに GraalVM native が Go にどこまで迫れるのか、を見ていきます。

    先に結論を書いておきます。

    • Java 25:メモリを十分に使える状態なら、動き始めてからの処理速度とマルチコアでの強さは 3 つの中で最も安定している。ただし、その速さの一部は大量のメモリと引き換えで、起動・1 回目の実行・メモリでは不利

    • GraalVM native:起動は Go とほぼ同じ 6ms。メモリも Java の数分の 1。ただし処理速度は Java より落ちる場面があり、ビルドの手間も大きい

    • Go:起動とメモリは最強。ただし大量のメモリ確保と、それを並列に行う処理は 3 つの中で最も弱い

    計測環境

    • マシン:MacBook Pro(Apple M2 Pro / メモリ 32GB / macOS 15)

    • Java:Amazon Corretto 25.0.4(最新の LTS)[1]

    • GraalVM:Oracle GraalVM 25.0.4(native-image は最適化レベル -O3)

    • Go:1.27.2(最新の安定版。Go には LTS がなく、直近 2 つのメジャー版がサポート対象です)[2]

    • JSON ライブラリ:Java は Jackson 2.22、Go は標準の encoding/json

    各ベンチマークは、プロセスごとに 10 回実行し、それを 5 プロセス分 繰り返しました。結果1〜3 の数値は 5 回の計測の中央値 で、ばらつきはほとんどのベンチマークで ±5% 以内でした。起動時間と追加検証は、それぞれの節に書いた方法で別に計測しています。

    テストデータは Java と Go で同じ疑似乱数から作り、計算結果(チェックサム)が一致することを確認しています。つまり、まったく同じ処理を比べています。

    ※ GraalVM の JVM で普通に動かす方式(GraalVM JIT)も測りました。結果は最後に補足として載せます。

    何を測ったか

    計算系:言語そのものの速さ

    • fib:再帰呼び出しで fib(35) を計算

    • sieve:エラトステネスの篩で 2,000 万までの素数を数える

    • binarytrees:二分木を大量に作っては捨てる(メモリ確保と GC の速さ)

    • hashmap:200 万件の登録と 400 万回の検索

    • sort:500 万件の整数をソート

    • string:100 万個の文字列を連結して、分割して、数値に変換

    実務系:業務アプリでよくある処理

    • json:注文データ 5 万件を JSON に変換して元に戻す

    • csv:売上 CSV 100 万行を読み込み、地域 × 月で集計

    • regex:アクセスログ 30 万行を正規表現で解析

    • sha256:64MB のデータを 4KB ごとにハッシュ計算

    • http:ローカルの HTTP サーバーに 64 並列で 2 万リクエスト

    結果1:計算系(動き始めてからの速さ)

    ※ 結果1〜3 は、メモリの上限を指定しない状態(Java は最大 8GB まで使える)での結果です。メモリ量を揃えた比較は、追加検証1で行います。

    画像
    • 単純な計算(fib・sieve)は、3 つとも大きな差なし(差は最大 1.4 倍)。ループや関数呼び出しは、どの方式でも十分に最適化されます。

    • 大量のメモリ確保(binarytrees)は Java と GraalVM native が圧勝。Go は Java の 3.6 倍、GraalVM native の 3.1 倍の時間がかかりました。Java の GC は「ほとんどのオブジェクトは作られてすぐ不要になる」という性質を利用した世代別の方式で、短命なオブジェクトを大量に作って捨てる処理を効率よく片付けられます[3]。GraalVM native の GC(Serial GC)も同じく世代別の方式です[9]。

    • hashmap と string は Java が最速。GraalVM native は Java の 3.0 倍(hashmap)、1.7 倍(string)の時間がかかり、Go よりも遅くなりました。ただし、この Java の速さはメモリを大量に使えた結果で、メモリ量を揃えると Go のほうが速くなります(追加検証1)。

    • sort は逆に GraalVM native が最速で、Java より 1.6 倍速い結果でした。

    結果2:実務系(動き始めてからの速さ)

    画像
    • JSON は Java が最速(54.8ms)。GraalVM native(77.6ms)、Go(94.8ms)と続きます。ただし Java は外部ライブラリの Jackson、Go は標準ライブラリでの比較です。ライブラリの選び方で結果は変わります。

    • CSV の集計は Go が最速(121ms)。GraalVM native(183ms)、Java(272ms)の順でした。

    • 正規表現は Java が最速(122ms)。GraalVM native(208ms)、Go(301ms)の順です。Go の正規表現は、どんなパターンでも入力の長さに比例した時間で処理を終えることを保証した方式です[4]。Java のようなバックトラック型の方式は、特定のパターンで処理時間が爆発的に増えることがある一方[5]、今回のような普通のパターンでは Java のほうが速い結果になりました。 なお、この計測は 11 本のベンチマークを 1 つのプロセスで続けて実行しています。1 本ずつ別のプロセスで動かすと、Java の regex は 85ms、csv は 243ms まで速くなりました(Go と GraalVM native はほぼ変わらず)。Java の JIT が、前に動かしたベンチマークの実行情報の影響を受けたためと考えられます。どちらも順位は変わりません。

    • SHA-256 は Java と Go がほぼ同じで、GraalVM native だけ 14 倍遅い結果でした。理由は後の考察で説明します。

    • HTTP は 3 つとも大差なし(Go が 1 割ほど速い程度)。なお Java 側は、JDK 標準の簡易 HTTP サーバー(jdk.httpserver)を使っています。公式ドキュメントでも「ローカルでのテストや開発向けで、高性能なサーバーを意図していない」とされているもので[19]、本番でよく使われる Netty や Tomcat とは別物です。

    結果3:1 回目の実行(ウォームアップなし)

    ここで、Java と GraalVM native の違いがはっきり出ます。

    画像

    Java は、実行しながら「よく通る処理」を見つけて最適化していきます。そのため 1 回目は遅く、2 回目以降で速くなります。

    • JSON:Java は 1 回目 209ms → 2 回目以降 55ms

    • HTTP:Java は 1 回目 1,130ms → 2 回目以降 605ms

    一方、GraalVM native と Go は事前にコンパイル済みなので、1 回目から速い。JSON・CSV・HTTP の 1 回目は、どれも Go が最速、GraalVM native が 2 位、Java が最下位でした。

    結果4:起動時間

    画像
    • Go:5.8ms

    • GraalVM native:6.0ms

    • Java 25:31.1ms

    GraalVM native にすると、起動は Go とほぼ同じになります。Java の約 5 分の 1 です。

    追加検証1:実際のメモリ使用量を揃えると

    「Java はメモリを多く使っているから速いだけでは?」という疑問に答えるため、メモリ量を揃えて比べました。

    ここで注意が必要なのは、メモリの上限設定を揃えても、実際の使用量は揃わないことです。Java は、上限を指定しないと物理メモリの 1/4(今回は 8GB)まで使ってよい設定で動きます[6]。試しに、Java と GraalVM native は -Xmx、Go は GOMEMLIMIT で上限を 256MB にして計算系を動かしてみると、実際の使用量は Java 322MB、GraalVM native 248MB、Go 92MB でした。-Xmx が制限するのはヒープ(オブジェクトを置く領域)だけで、JVM 自体が使うメモリは含まれないためです。

    そこで、ベンチマークごとに各方式のメモリ設定を何段階も変えて実行し、実際のメモリ使用量(peak RSS)と処理時間の組を記録しました。Java と GraalVM native は -Xmx を 64MB〜1GB の 8 段階、Go は GOGC(大きくするとメモリを多く使う代わりに GC の回数が減る)と GOMEMLIMIT を 6 段階で変えています。

    画像

    メモリを多く使って速くなっていたもの

    • hashmap:結果1の Java 61.7ms は、メモリの上限なしでの値でした。実際の使用量を 256MB 以内に揃えると、Java 208ms(240MB)に対して Go 165ms(64MB)で、Go のほうが速くなります。Java は上限 128MB ではメモリ不足で動きませんでした。

    • string:256MB 以内に揃えると、Java 59.5ms(244MB)に対して Go 33.0ms(94MB)。こちらも Go が速くなります。

    Java の HashMap は、数値をそのまま保存できず、Integer というオブジェクトに包んで保存します[18]。Go の map[int32]int32 は数値をそのまま保存するので、同じデータでも必要なメモリが大きく違います。この 2 つでの Java の速さは、メモリの多さで勝っていたと言えます。

    メモリを揃えても Java 系が速かったもの

    • binarytrees:128MB 以内に揃えても、Java 214ms(106MB)、GraalVM native 212ms(115MB)に対して Go 559ms(95MB)。Go にメモリを 171MB まで使わせても 552ms までしか縮まらず、約 2.6 倍の差は埋まりませんでした。メモリ量ではなく、GC の方式の違いによる差と考えられます。

    • json:256MB 以内なら、Java 54.8ms(232MB)に対して Go 93.0ms(178MB)。Go はメモリを増やしても 93〜100ms でほとんど変わりませんでした。ただし 128MB 以内に絞ると、Java は動かず、Go は 98.4ms(81MB)で動きます。

    • regex:Java 83.3ms(154MB)に対して Go 297.7ms(88MB)。Java はメモリを増やしても 83〜85ms でほとんど変わらないので、メモリではなく正規表現の方式の違いによる差と考えられます。

    少ないメモリでは、そもそも動かない

    使用量 64MB 以内という厳しい条件で動いたベンチマークの数は、Go 7 本、GraalVM native 5 本、Java 2 本(全 11 本中)でした。 メモリをほとんど使わない計算(fib)でも、Java は 42MB を使います。一方 Go は 7MB、GraalVM native は 8MB です。JVM 自体が使う分だけ、Java には「最低限必要なメモリ」があります。

    メモリの予算ごとに見ると

    使えるメモリの予算を決めて、その中で最速だった方式の数を数えると、こうなりました(全 11 本中)。

    • 128MB 以内:Go 6 本、GraalVM native 4 本、Java 1 本

    • 256MB 以内:Go 5 本、Java 4 本、GraalVM native 2 本

    • 512MB 以内:Java 5 本、Go 4 本、GraalVM native 2 本

    メモリの予算が小さいほど Go が有利で、予算が大きくなるほど Java が勝つ数が増えます。「メモリが大きいから速い」は半分正しく、半分は GC やライブラリの方式による本当の速さの差でした。

    追加検証2:マルチコアでの伸び方

    同じ量の仕事を 1〜12 スレッドで分担して、スレッドを増やすとどれだけ速くなるかを見ました(メモリの上限は指定していません)。

    画像
    • 計算だけの処理は、3 つとも同じように伸びました(12 スレッドで約 9.6 倍。12 コアのうち 4 つは性能の低い省電力コアなので、12 倍には届きません)。

    • メモリ確保が多い処理では、大きな差が出ました。

      • Java 25:6.6 倍

      • GraalVM native:3.1 倍(8 スレッドより 12 スレッドのほうが遅い)。GC が並列に動かない Serial GC のため、GC の間は 1 スレッドで回収することになります[9]

      • Go:2.6 倍

    12 スレッドでかかった時間で比べると、Java 98ms、GraalVM native 248ms、Go 1,123ms。Go は Java の約 11 倍の時間がかかりました。 Web アプリやバッチ処理は「メモリ確保が多い処理を並列に動かす」ことが多いので、この差は実務に効いてくる可能性があります。ただし、追加検証3の負荷試験ではここまでの差は出ませんでした。また、この検証はメモリの上限を指定せずに行っています。

    追加検証3:サーバーとして負荷をかけると

    各方式で JSON を返す API サーバーを立て、64 接続で 30 秒間、負荷をかけ続けました。

    画像
    • 処理件数は 3 つとも 毎秒 3.4〜3.6 万件 で、ほぼ同じ

    • 応答時間も、99% のリクエストが 2〜2.6ms 以内 で、ほぼ同じ

    • メモリだけは大差:Go 21MB、GraalVM native 55MB、Java 422MB(いずれもメモリの上限なし)

    正直に書くと、処理件数がそろってしまったのは、負荷をかけるツールも同じ Mac で動かしたため、ツール側が先に限界に来た可能性が高いです。サーバーの処理能力の差は、この方法では測りきれていません。 ただ、同じ仕事をこなしたときのメモリ使用量は、GraalVM native が Java の約 8 分の 1、Go は約 20 分の 1 という差ははっきり出ました。Java の値は「上限なしで使えるだけ使った」結果なので、上限を絞ればもっと小さくなります(追加検証1)。 また、前述のとおり Java 側のサーバーは JDK 標準の簡易サーバーです[19]。

    考察1:Java 25 と GraalVM native ── 同じコードの「動かし方」の違い

    まず、同じ Java のコードを、実行しながら最適化する(Java 25)か、事前にコンパイルする(GraalVM native)かで、何が変わるのかを整理します。

    画像

    GraalVM native で得られるもの

    • 起動が約 5 倍速い(31.1ms → 6.0ms)

    • 1 回目から速い:JSON は 1.8 倍、HTTP は 1.6 倍、1 回目の処理が速くなりました

    • メモリが少ない:負荷試験中のメモリは 422MB → 55MB(上限なしの場合)

    • JDK が不要:実行に必要なのは 50MB の実行ファイル 1 つだけ。Java は JDK 本体(今回の環境で 378MB)が必要です。ただし Java でも、jlink を使えば必要なモジュールだけに絞った実行環境を作れます[20]

    GraalVM native で失うもの

    • 動き始めてからの速度が落ちる処理がある:メモリ上限なしでは、hashmap は 3.0 倍、string と regex は 1.7 倍、JSON は 1.4 倍、Java のほうが速い結果でした。ただし同じだけメモリを使わせると差は縮まり、hashmap は 1.1 倍程度になります

    • マルチコアでの GC が弱い:メモリ確保が多い処理を並列にすると、Java の 6.6 倍に対して 3.1 倍しか伸びません(macOS での結果)

    • 既定のビルドでは CPU の専用命令が使われないことがある:SHA-256 が 14 倍遅かったのは、このためと考えられます

    なぜ速度が落ちるのか

    理由は、事前コンパイルの仕組みそのものにあります。

    • 実行中の情報を使えない:Java の JIT(HotSpot の実装)は、実際に動かしながら「各分岐を何回通ったか」「呼び出し先にどの型が来たか」といった情報(プロファイル)を集めます[7][17]。そのうえで、通らない分岐を省いたり、来る型を決め打ちしたりする思い切った最適化を行い、想定が外れたときは最適化を取り消してやり直します[17]。事前コンパイルでは、この実行中の情報がありません。Oracle GraalVM には、一度動かして情報を集めてからビルドし直す機能(PGO)もありますが[8]、ビルドの手間がさらに増えます。

    • GC の選択肢が少ない:native-image の既定の GC は Serial GC で、G1 GC が使えるのは Linux(AMD64 / AArch64)の Oracle GraalVM だけです[9]。Serial GC は並列に動かない方式なので[9]、macOS では、メモリ回収を並列にできる G1 GC を選べないことが、マルチコアで伸びない原因と考えられます。Linux の Oracle GraalVM で G1 GC を使えば、結果は変わる可能性があります。

    • 幅広い CPU 向けにビルドされる:既定では、多くの CPU で動くよう基準となる命令セット(AArch64 では armv8.1-a)向けにビルドされます[8]。今回の SHA-256 が遅かったのは、そのために SHA-256 の専用命令が使われなかったためと考えられます。ビルド時に -march=native を付けると、SHA-256 は 362ms → 約 30ms になり、Java と同等になりました。ただし -march=native は、ビルドしたマシンと同じ CPU で動かす前提の設定です[8]。

    開発の手間も大きく変わる

    • ビルド時間:javac は 1 秒未満。native-image は毎回 1 分強かかり、ビルド中に約 4GB のメモリを使いました。

    • リフレクションの設定:native-image は「ビルド時に使うクラスがすべて分かっている」ことが前提です。Jackson のようにリフレクションを使うライブラリは、そのための設定が必要になります。設定が漏れていると、ビルドは通っても実行時にエラーになります[10]。今回は GraalVM 付属のトレースエージェントで、実際に動かして設定を自動生成しました[11]。

    • できないことがある:native-image は「すべてのコードがビルド時に分かっていて、実行時に新しいコードを読み込まない」ことを前提にしています[12]。そのため、実行中に新しいクラスを読み込むような動的な仕組みは使えません。

    まとめると、GraalVM native は「起動・1 回目・メモリ」を取るために、「ピーク性能・並列 GC・開発の手軽さ」を差し出す技術です。

    考察2:GraalVM native は Go になれたか

    では、GraalVM native は Go にどこまで迫れたのでしょうか。

    互角、または GraalVM native が勝ったところ

    • 起動時間:6.0ms と 5.8ms で、ほぼ互角

    • 大量のメモリ確保:binarytrees は GraalVM native が Go の 3.1 倍速い

    • 並列での絶対速度:メモリ確保が多い処理を 12 スレッドで動かすと、GraalVM native 248ms に対して Go は 1,123ms。伸び方はどちらも弱いものの、絶対的な速さでは GraalVM native が 4.5 倍速い

    • 正規表現と JSON:GraalVM native が Go より 1.2〜1.5 倍速い

    • 1 回目の実行:JSON・CSV・HTTP では Go が少し速いが、差は 1.2〜1.6 倍程度

    Go が勝ったところ

    • メモリ:負荷試験中は Go 21MB、GraalVM native 55MB。計算系でも Go は GraalVM native の半分以下

    • 実行ファイルのサイズ:Go 9.9MB、GraalVM native 50MB

    • ビルド時間:Go はフルビルドでも 8 秒。GraalVM native は 1 分強

    • CSV・文字列処理:Go が 1.5〜1.7 倍速い

    • 何も設定しなくても速い:Go の標準ライブラリは、CPU が SHA-256 の専用命令に対応していれば自動で使います[13]

    つまり、起動の速さでは GraalVM native は Go に追いついたと言えます。処理速度でも、メモリ確保の多い処理では Go を上回ります。 一方で、メモリの少なさ、ビルドの速さ、手軽さでは、Go にまだ及びません。

    GraalVM native は「Go と同じ土俵に立てる Java」ですが、「Go そのもの」にはなっていない、というのが実感です。

    考察3:なぜ「Java は遅い」と思われているのか

    結果をまとめると、こうなります。

    • 長く動かしたときの処理速度 → Java が速い場面が多い

    • 起動・1 回目の実行・メモリ → Go が最強で、GraalVM native が迫る。Java は不利

    「Java は遅い」という印象は、主に後者から来ていると考えています。

    • 起動が遅い:コマンドラインツールが「もっさり」する

    • 1 回目が遅い:デプロイ直後の最初のリクエストが遅い

    • メモリが多い:サーバーの台数やコンテナの数が増える

    • フレームワークが重い:Spring Boot などのフレームワークを載せると、起動はさらに遅くなる(今回は測っていません)

    • 昔の Java の印象:登場した当初の Java が遅かったころのイメージが、今も残っている(私見です)

    逆に言えば、メモリを十分に使える状態で動き始めてしまえば、Java は 3 つの中で最も安定して速いのです。ただし、その速さの一部はメモリを多く使うことで得ています。メモリを絞った条件では Go が速くなる処理もあり、「Java は速い」も無条件ではありません(追加検証1)。

    考察4:クラウドネイティブでは、起動の遅さが致命的になる

    では、普通の Java で問題ないかというと、そうではありません。クラウドネイティブな環境では、起動の遅さがそのままスケール性能に直結するからです。

    • スケールアウトが間に合わない:急にアクセスが増えてコンテナを追加しても、起動して暖まるまでの間はさばけません。今回も、Java の 1 回目の HTTP 処理は 2 回目以降の約 2 倍の時間がかかりました。

    • サーバーレスのコールドスタート:リクエストが来てから起動する方式では、起動時間がそのまま応答時間に乗ります。

    • メモリが台数に響く:負荷試験中(上限なし)、Java は GraalVM native の約 8 倍、Go の約 20 倍のメモリを使いました。1 コンテナのメモリが大きいほど、同じサーバーに載せられる数は減ります。

    3 つを並べると、こう整理できます。

    • Java 25:そのままでは不利。対策として、起動時の準備や最適化の結果を前もって保存しておく仕組み(Project Leyden。Java 24〜25 から段階的に導入)[14][7]や、暖まったプロセスの状態を保存して再開する仕組み(CRaC[15]、AWS Lambda の SnapStart[16])が出てきています

    • GraalVM native:起動とメモリの問題を大きく改善できる。代わりに、CI でのビルド時間(1 回 1 分以上)と、リフレクション設定の管理が必要になる

    • Go:何もしなくても最初から有利。追加の手間がない

    つまり、Java でクラウドネイティブの土俵に立つ方法はあるものの、どれも追加の手間がかかります。Go は最初からその土俵にいる、というのが最大の違いです。

    考察5:AI 時代のコーディングでは、どれが有利か

    最後に、AI と一緒にコードを書く時代に、3 つのどれが向いているかを考えます。ここからは計測ではなく、私の考察です。

    オブジェクト指向かどうかより「書いてあるとおりに動くか」

    Java はオブジェクト指向、Go は手続き型、と言われることがあります。ただ、Go も構造体やインターフェースを持っていて、継承を持たない代わりに小さな部品を組み合わせて作る、という設計です。

    AI にとっての扱いやすさを左右するのは、オブジェクト指向かどうかより、「コードに書いてあることが、そのまま動くか」 だと考えています。

    • Go:暗黙の処理がほとんどない。1 つの関数を読めば、何が起きるかが分かる

    • Java 25:アノテーションや DI(部品を自動でつなぐ仕組み)、継承によって、処理の流れがコードの外や別のファイルに散らばりやすい

    • GraalVM native:Java の暗黙のルールに加えて、「ビルド時に使うクラスがすべて分かっていること」という制約が増える。リフレクションの設定漏れは、ビルドではなく実行時に初めてエラーになる[10]

    実際、今回のベンチマークのコードも AI と一緒に書きましたが、つまずいたのは Java 側でした。起動時に static 初期化で Jackson が動いてしまった、native-image 用のリフレクション設定が必要だった、といった「コードに書かれていないルール」が原因です。Go 側では同じような問題は起きませんでした。

    暗黙の処理や先回りの設計は、人間のための仕組みだった

    アノテーションや DI、凝ったクラス設計の多くは、人間がチームで開発し、同じコードを何度も書かずに済ませ、部品を再利用するために生まれたものです。

    AI にとって、同じようなコードを書くのはほぼタダです。書き直すのも速い。そうなると、

    • 定型コードを省くための暗黙の処理

    • 「いつか再利用するかもしれない」ための先回りの抽象化

    は、AI のコーディングではむしろ邪魔になります。AI は処理を追うために何ファイルも行き来することになり、どこを直すべきかを間違えやすくなるからです。

    ちなみに、暗黙の処理(特にリフレクション)が少ないコードは、GraalVM native とも相性が良くなります。「AI に書かせやすい Java」と「native-image にしやすい Java」は、実はかなり重なっています。

    ただし、すべての設計が不要になるわけではない

    一方で、次のような設計は、AI にとってもむしろ重要です。

    • 部品の境界:「この部品は注文の計算だけをする」と区切られていれば、AI はその部品だけを読んで安全に直せる

    • 型:金額や注文 ID を専用の型にしておけば、取り違えをコンパイラが止めてくれる

    • 外部とのつなぎ目:データベースや外部 API を切り離しておけば、テストで差し替えて動作を確かめられる

    • テスト:AI が自分の変更で何かを壊したときに、すぐ気づける

    いらなくなるのは「人間の手間を省くための設計」で、むしろ大事になるのは「変更の影響範囲を小さくするための設計」だと考えています。

    私の進め方:抽象化は後から

    私自身は、AI でコードを書くようになる以前から、次の方針でコーディングしています。

    1. 最初は具体的に書く。重複しても気にしない

    2. 同じ処理が 3 回出てきたら、そこで共通化する

    3. 共通化の前に、テストで今の動きを固定しておく

    先回りして作った抽象化は、結局使われなかったり、実際の要件と合わずに作り直したりすることが多い、というのが経験からの実感です。必要になった時点で作れば十分です。

    この方針は、AI と組み合わせると、さらに効果が高まると感じています。AI なら書き直しのコストが安いので、「後から共通化する」ときの負担がほとんどありません。同じ処理が 3 回出てきたら、AI に共通化を任せればよいのです。

    Java でも Go でも、同じ方針で書ける

    私は Java と Go の両方を使っていますが、どちらの言語でもこの方針で書いています。同じ「注文」と「支払い方法」を、それぞれで書くとこうなります。

    // Java:データは record、種類の違いは sealed + パターンマッチング
    record Order(long id, String customer, List<Item> items) {}
    
    sealed interface Payment permits Card, BankTransfer {}
    record Card(String number) implements Payment {}
    record BankTransfer(String account) implements Payment {}
    
    static long fee(Payment p) {
        return switch (p) {          // 種類の追加漏れはコンパイルエラーになる
            case Card c -> 300;
            case BankTransfer b -> 0;
        };
    }
    
    // Go:データは struct、種類の違いは interface + 型 switch
    type Order struct {
        ID       int64
        Customer string
        Items    []Item
    }
    
    type Payment interface{ isPayment() }
    type Card struct{ Number string }
    type BankTransfer struct{ Account string }
    
    func (Card) isPayment()         {}
    func (BankTransfer) isPayment() {}
    
    func fee(p Payment) int64 {
        switch p.(type) {
        case Card:
            return 300
        case BankTransfer:
            return 0
        }
        panic("unknown payment") // 種類の追加漏れは実行するまで分からない
    }
    

    どちらも、継承を使わず、データと処理を素直に書いています。違いは次の 2 点です。

    • Go は、言語そのものがこの書き方に寄せてくれる:継承もアノテーションもないので、AI に書かせても自然とシンプルなコードになります。一方で、種類の追加漏れはコンパイラが教えてくれません。

    • Java は、書き方を選べば同じことができ、しかも安全網が強い:record や sealed interface を使えば Go と同じくらい具体的に書けて、種類の追加漏れもコンパイラが止めてくれます。

    この「追加漏れをコンパイラが止める」仕組みは、AI に書かせる場合こそ効いてきます。

    • AI も見落とす:AI が一度に読めるコードの量には限りがあります。新しい支払い方法を追加するとき、関係する switch がプロジェクトのあちこちにあると、AI はその一部を見落とすことがあります。

    • 見落としに機械的に気づける:Java なら、見落とした箇所はコンパイルエラーとして必ず表に出ます。Go では、コンパイラは教えてくれないので、テストでその分岐を通らない限り、本番で panic するまで気づけないことがあります。

    • AI が自分で直せる:コンパイルエラーには「どこで、何が足りないか」が書かれているので、AI はそれを読んで自分で修正できます。人がレビューで探すより、確実で速い方法です。

    AI にとってコンパイラは、書いたコードをすぐに確かめてくれる「もう 1 人のレビュアー」です。AI 任せで書くほど、コンパイラが見つけてくれる範囲が広い言語のほうが安心できます。Go で同じ安全網がほしい場合は、テストで全種類の分岐を通すか、型 switch の網羅性を調べる外部の静的解析ツール(go-check-sumtype など[21])で補う必要があります。

    ただし Java には注意点もあります。AI が学んだ Java のコードには、昔ながらの業務系の書き方が大量に含まれています。何も指示しないと、AI は実装が 1 つしかないインターフェースや、何層にも分かれたクラス構造を勝手に作ります。AI への指示に「record と static メソッドで書く」「実装が 1 つのインターフェースは作らない」「継承は使わない」と書いておくのが効果的です。

    まとめると、Go は言語がシンプルな書き方を守ってくれ、Java はその書き方を自分(と AI への指示)で守る代わりに、コンパイラの安全網が強い、という違いです。どちらを使う場合でも方針は同じで、そしてその書き方を徹底した Java は、GraalVM native にもしやすくなります。

    まとめ:3 つをどう選ぶか

    メモリ効率という視点

    今回わかった大事な点の 1 つは、「速さ」はメモリの使い方とセットで評価しないと意味がないということです。

    • Java:メモリを多く使えるほど速くなる。予算が 512MB あれば、11 本中 5 本で最速。ただし最低でも数十 MB が必要で、データの持ち方(数値をオブジェクトに包む)によってはメモリを大きく消費する

    • GraalVM native:Java より少ないメモリで動き、同じメモリなら Java に近い速さが出る処理も多い。予算 128MB では 4 本で最速

    • Go:少ないメモリでも速度が落ちにくい。予算 128MB では 6 本で最速。ただし、メモリを増やしても速くならない処理が多く、GC の重い処理では Java 系に届かない

    クラウドでは、メモリはそのままコストです。1 台のサーバーに何個のコンテナを載せられるか、サーバーレスで何 MB のメモリ枠を選ぶかが、料金に直結します。同じ処理を少ないメモリでこなせることは、速さと同じくらい重要な性能だと考えています。

    3 つの選び方

    • Java 25 を選ぶ場面:長時間動くサーバーやバッチ処理で、メモリを十分に割り当てられ、GC の重い処理やマルチコアを使い切りたいとき。メモリを使える分だけ速くなる。Java の資産やライブラリをそのまま使える

    • GraalVM native を選ぶ場面:Java の資産を活かしたまま、コンテナやサーバーレスで速く起動し、メモリも抑えたいとき。起動は Go 並み、メモリは Java の数分の 1。ただしビルドに時間がかかり、ピーク性能と並列 GC は Java に劣る

    • Go を選ぶ場面:クラウドネイティブで、起動・メモリ・配布の手軽さを最優先したいとき。少ないメモリでも速度が落ちにくく、何も工夫せずに最初から有利。AI と一緒にシンプルに書くのにも向いている。ただし GC の重い処理を並列に行うのは苦手

    「Java は遅い」は、起動とメモリについては正しく、動き始めてからの処理速度については、メモリを十分に使える条件では正しくありませんでした。 そして GraalVM native は、その「起動とメモリ」の弱点を Go に近いところまで埋められる技術でした。ただし、その代わりに差し出すものもあります。

    クラウドネイティブと AI の時代には、「起動とメモリ」と「シンプルさ」の重みが増しています。その意味で Go が有利な場面は確実に増えていますが、Java にも GraalVM native とモダンな書き方という選択肢がある、というのが今回の実感です。

    あなたの用途なら、3 つのうちどれを選ぶでしょうか。この記事の数字が、その判断材料の 1 つになれば幸いです。

    なお、計測はすべて 1 台の Mac(macOS)で行ったものです。クラウドの本番環境で多い Linux では、GraalVM native で G1 GC が使えるなど条件が変わるため、結果も変わる可能性があります。また、どの方式も GC などのチューニングはしていません。気になった方は、ぜひ手元の環境で試してみてください。

    補足:GraalVM JIT の結果

    GraalVM の JVM で普通に動かす方式(GraalVM JIT)も測りました。Java 25 と同じく実行しながら最適化する方式で、最適化を担当するコンパイラだけが違います。

    • 動き始めてからの速度は、11 本中 5 本で 4 つの中の最速:binarytrees 131ms(Java 25 は 183ms)、sort 308ms(同 519ms)、regex 88ms(同 122ms)

    • 起動は 50.8ms と、4 つの中で最も遅い

    • メモリの使い方は Java 25 とほぼ同じ

    「とにかくピーク性能がほしい長時間処理」なら、GraalVM JIT も選択肢になります。

    参考資料

    計測結果以外の、仕組みや仕様に関する記述は、以下の資料にもとづいています(2026 年 10 月に確認)。

    #エンジニア ​
    #ITエンジニア ​
    #開発 ​
    #ウイングアーク ​
    #ウイングアーク1st ​
    #テックブログ ​
    #エンジニア転職 ​
    #エンジニア採用 ​

    あなたへのおすすめ