2025/04/10

バイトコード入門 その5 オブジェクト生成、メソッドコール

このエントリーをはてなブックマークに追加

前回、スタックマシーンとしてのJVMの基本的な動作を紹介しました。

プリミティブ型の加算という簡単な処理ですが、これが分かればより複雑なバイトコードでも理解できるはずです。

そこで、今回はもう少し複雑な例としてオブジェクトの生成やメソッドコールについて紹介します。

  1. 準備編
  2. スタックマシン
  3. バイトコード処理の構成
  4. バイトコード処理の基礎
  5. オブジェクト生成、メソッドコール (今回)

 

命令セット

今までバイトコードのオペコード(命令、もしくはインストラクション)について簡単な説明しかしていなかったので、ここで紹介しましょう。

とはいってもすべてを紹介するのは大変ですし、おぼえても意味はないので、主に使われるオペコードについて見ていきます。

また、if文やfor文、switch式などの制御構造に関するバイトコードは次回紹介します。

 

オペコードの詳細な定義はJVMSのChapter 6にあります。

リンクはJava 24のJVMSです。JVMSも毎バージョンごとにアップデートされているので、なるべく最新を参照するようにしてください。

 

オペコードの構成

現在定義されているオペコードは200種類ほどあります。しかし、それらがすべて違う動作を表しているわけではありません。動作は同じだけど型が違う、動作は同じだけどローカル変数配列のインデックスが違うなどがあります。

型について接頭辞、インデックスなどは接尾辞で表します。接尾辞はインデックス以外にも繰り返し回数などがあり、オペコードによって意味が異なります。一方の接頭辞は常に型を表します。接頭辞の一覧を次に示します。

接頭辞
i int
l long
s short
b byte
c char
f float
d double
z boolean
a 参照

オペランドスタックやローカル変数配列にはプリミティブ型の値か参照しか入れることができません。このため、オブジェクトを扱う場合はヒープに存在するオブジェクトへの参照として扱われます。

もしかしたら、今後導入が予定されているValue Classであれば、直接オペランドスタックに積めるようになるかもしれません。

とはいうものの、バイトコードが増えるわけではなく、あくまでも最適化された場合に限るはずです。

 

たとえば、前回使用したオペランドのiload_1は、接頭辞がi、接尾辞が_1です。つまり、int型のloadで、ローカル変数配列のインデックス1からのロードということを表しています。

 

主なオペコード

オペコードが本体と接頭辞、接尾辞から構成されることが分かったところで、主なオペコードについて見ていきましょう。

 

スタック操作

オペランドスタックに対して何らかの操作を行うオペコードです。オペランドスタックと書くと長くなるので、以下では単にスタックと表記します。

  • ldc: コンスタントプールの定数をスタックに積む
  • const: インデックスで指定された値をスタックに積む (型、接尾辞あり)
  • bipush/sipush: byte値、short値をスタックに積む
  • pop: スタックから値を取り除く
  • dup: スタック末尾の要素を複製
  • swap: スタック末尾の2データを入れ替え

ldcはロードコンスタントのことですね。コンスタントプールは定数で書き換えることはないため、ストアはないです。

constは接尾辞で値を指定します。int型の1であれば iconst_1 となります。接尾辞は-1(m1)から5まであり、これを超える範囲の場合、次に紹介するbipush/sipushを使用します。

bipush/sipushもconstに似ていますが、byte値もしくはshort値を直接スタックに積みます。他の型はありません。

整数型の変数で、byteもしくはshortの範囲に収まるものはbipush/sipushが使われます。shortを超える範囲の場合、コンスタントプールにある定数を使用してldcが使われます。

 

ローカル変数

オペランドスタックとローカル変数配列とのやり取りに関するオペコードです。

  • load: ローカル変数配列の値をスタックに積む (型、接尾辞あり)
  • store: スタックから値を取り出し、ローカル変数配列に置く (型、接尾辞あり)

接尾辞のインデックスは0, 1, 2しかないため、それ以上の配列インデックスは iload 5 のようにオペコードの後に指定します。

 

算術演算

四則演算などの算術演算を行うオペコードです。

  • add: 加算 (型あり)
  • sub: 減算 (型あり)
  • mul: 乗算 (型あり)
  • div: 除算 (型あり)
  • rem: 除算の余り (型あり)
  • neg: 符号反転 (型あり)
  • iinc: インクリメント

インクリメントを行うiincはint型だけです。long型の場合はladdが使われます。

 

論理演算

AND/OR/XORとシフト演算を行うオペコードです。

  • iand/land: 論理積
  • ior/lor: 論理和
  • ixor/lxor: 排他論理和
  • ishl/lshl: 左シフト
  • ishr/lshr: 右シフト (符号は維持)
  • iushr/lushr: 右シフト

論理演算はint型とlong型に対してのみ存在します。byte/short/charに対してint型のオペコードが使われます。

 

オブジェクト関連

オブジェクトの生成などで使用するオペコードです。

  • new: インスタンス生成
  • getfield: インスタンス変数の値をスタックに積む
  • putfield: スタックから値を取り出し、インスタンス変数に代入
  • getstatic: クラス変数の値をスタックに積む
  • putstatic: スタックから値を取り出し、クラス変数に代入

newはインスタンスを生成するだけで、コンストラクターのコールは含まれていません。

コンストラクターのコールは、メソッドコールのバイトコードで行います。具体的な例は後述します。

getfield/putfieldは接頭辞による型の指定はありませんが、オペコードの後に指定します。getstatic/putstaticでも同じです。

 

配列関連

配列の生成や配列からの値の取り出し、代入などで使用するオペコードです。

  • newarray: プリミティブ型を要素にとる配列の生成
  • anewarray: 参照型を要素にとる配列の生成
  • multianewarray: 多次元配列の生成
  • aload: 配列のインデックスの要素をスタックに積む (型あり)
  • astore: スタックから値を取り出し、配列のインデックスの要素に代入 (型あり)
  • arraylength: 配列の長さをスタックに積む

Javaでは配列はオブジェクトの一種、つまり参照型として表されます。しかし、配列を扱うためのバイトコードも提供されています。

loadやstoreに接頭辞のaがついているのは、配列が参照型だからです。さらに要素の型をその前に接頭辞として付加します。たとえば、int型の配列から値を取り出すときはialoadになります。

 

メソッドコール

メソッドコールを行うバイトコードはメソッドの種類により5種類提供されています。

  • invokevirtual: インスタンスメソッド
  • invokeinterface: インタフェースメソッド
  • invokestatic: クラスメソッド
  • invokespecial: コンストラクター、プライベートメソッド、スーパークラスのインスタンスメソッド
  • invokedynamic: コールするメソッドを実行時に決定させるメソッドコール
  • return: メソッドから返る。(型あり)

メソッドの種類によってオペコードを変えますが、メソッド種類ごとにスタックに積んでおく値も異なります。たとえば、インスタンスメソッドであればコールするメソッドのオブジェクトが必要ですが、クラスメソッドであれば必要ありません。

特殊なのがinvokedynamicです。invokedynamicでは初回コール時にbootstrapという指定されたメソッドをコールし、ターゲットとなるメソッドを同定させてから、メソッドコールを行います。

2回目以降は同定したメソッドコールを直接行います。

invokedynamicに関しては、YujiSoftwareさんとJJUG CCCでセッションを行ったので、その資料をご参照ください。

 

メソッドから返るのがreturnです。int型の値を返すのであればがireturnになりますが、返り値がない場合はreturnのまま使用します。

 

残りは次回に回しましょう。

前回は算術演算を行うメソッドだけだったので、今回はその残りの部分の動作を見ていきます。

 

オブジェクト生成、メソッドコール

前章でオペコードにどのようなものがあるか紹介したので、実際にこれらのオペコードを使っていく様子を見てみましょう。

題材は前回と同じ足し算を行うだけのAdderクラスです。

public class Adder {
    public int add(int x, int y) {
        int z = x + y;
        return z;
    }

    public void static main(String... args) { 
        Adder adder = new Adder();
        int result = adder.add(2, 3);
        System.out.println(result);
    }
}

 

前回はaddメソッドの実行を見ましたが、今回はmainメソッドです。

Adderクラスをコンパイルオプションの-gを付加してコンパイルし、javap -vでmainメソッドを逆コンパイルしたのが以下です。

  public static void main(java.lang.String...);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0089) ACC_PUBLIC, ACC_STATIC, ACC_VARARGS
    Code:
      stack=3, locals=3, args_size=1
         0: new           #7    // class Adder
         3: dup
         4: invokespecial #9    // Method "<init>":()V
         7: astore_1
         8: aload_1
         9: iconst_2
        10: iconst_3
        11: invokevirtual #10   // Method add:(II)I
        14: istore_2
        15: getstatic     #14   // Field java/lang/System.out:Ljava/io/PrintStream;
        18: iload_2
        19: invokevirtual #20   // Method java/io/PrintStream.println:(I)V
        22: return
      LineNumberTable:
        line 8: 0
        line 9: 8
        line 10: 15
        line 11: 22
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      23     0  args   [Ljava/lang/String;
            8      15     1 adder   LAdder;
           15       8     2 result   I
}

 

mainメソッドがコールされた時のオペランドスタックとローカル変数配列の初期状態は次のようになります。

 

addメソッドはインスタンスメソッドだったので、ローカル変数配列のインデックス0にはthisが格納されていました。しかし、mainメソッドはクラスメソッド(staticメソッド)なので、thisはありません。そのため、インデックス0にはmainメソッドの引数が格納されます。

argsは文字列の配列ですが、それがそのままローカル変数配列に格納されるわけではありません。文字列配列argsの実態はヒープに作成され、ローカル変数配列にはその参照が格納されます。

 

コンスタントプール

mainメソッドでは、最初にAdderオブジェクトを生成し、adder変数に代入しています。

まずはAdderオブジェクトの生成です。

0行のnew #7がオブジェクトを生成している部分です。この#7はコンスタントプールへの参照になります。

addメソッドではコンスタントプールを使用することがなかったので、ここで触れておきましょう。

javap -vの出力にはコンスタントプールが含まれています。その一部を以下に示します。

Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Class              #8             // Adder
   #8 = Utf8               Adder
   #9 = Methodref          #7.#3          // Adder."<init>":()V
  #10 = Methodref          #7.#11         // Adder.add:(II)I
  #11 = NameAndType        #12:#13        // add:(II)I
  #12 = Utf8               add
  #13 = Utf8               (II)I

 

コンスタントプールは番号付きでこのように並べられています。

さて、先ほどのnew #7の#7を見てみるとClass #8とあります。Classは文字通りクラスを示しています。そのクラス名が#8になります。

#8は、Utf8 Adderです。Utf8は文字列定数を示しています。実際にクラスファイルでは、文字列をUTF-8で表記しています。そして、その後の"Adder"がその文字列定数の実態です。

つまり、#7でクラスを示し、そのクラス名は#8で"Adder"であるということを示しています。

 

オブジェクト生成

では、mainメソッドに戻りましょう。

new #7では、Adderクラスのオブジェクト生成を行い、その結果、ヒープに生成したオブジェクトの参照をオペランドスタックに積みます。

 

ここまではオブジェクトの生成をしただけの状態で、コンストラクターはコールしていません。

mainメソッドの3行、4行がコンストラクターをコールする部分です。

まず、3行でdupを行います。dupはduplicateのコートで、スタックの値を複製します。

ここではAdderオブジェクトへの参照を複製します。

 

そして、その後のinvokesupecialでコンストラクターをコールします。

invokespecialはコンストラクター、プライベートメソッド、スーパークラスのインスタンスメソッドをコールするためのオペコードです。

コールするメソッドが、コンスタントプールの#9です。#9の部分を見てみると...

   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Class              #8             // Adder
   #8 = Utf8               Adder
   #9 = Methodref          #7.#3          // Adder."<init>":()V

 

#9はMethodrefで、メソッドへの参照を示しています。その値の#7は先ほど見たようにAdderクラスを指しています。

#3を見てみると、NameAndTypeとなっています。これはメソッド名とメソッドのシグネチャー(引数と戻り値の型)を示しています。

NameAndType #5:#6の#5がメソッド名、#6がシグネチャーです。

#5を見てみると、文字列定数で<init>です。

コンストラクター名は、Javaのコードではクラス名と同じですが、バイトコードではどのクラスでも<init>になります。

シグネチャーを表すのが、#6の文字列定数の()Vです。

()の中に引数の型が示されますが、Adderクラスのコンストラクターはデフォルトコンストラクターで引数なしなので、単に()となっています。

()の後に示されるのが、戻り値の型です。Vはvoid、つまり戻り値なしです。

コールするメソッドが分かったので、実際にコールするわけですが、その時にオペランドスタックの値が使われます。

ここでは、Adderオブジェクトへの参照が2つスタックに格納されていますが、1つがコールするメソッドのオブジェクト、そしてもう1つがそのメソッドへの暗黙の引数と考えることができます。

オブジェクト生成はnew, dup, invokespecialが常にセットになっているので、そういうものだと考えていただいて大丈夫です。

invokespecialを実行すると、mainメソッドはそのままにして、Adderクラスのコンストラクターを実行するフレームがJVMスタックに積まれます。

 

そして、コンストラクターの実行が完了すると、コンストラクターのフレームが取り除かれて、mainメソッドが再開します。

オペランドスタックには、コンストラクターをコールした後のAdderオブジェクトが積まれます。

 

さて、その後の7行のastore_1で、Adderオブジェクトの参照をローカル変数配列のインデックス1に格納します。

 

これで、Adder adder = new Adder();の処理が完了しました。

 

インスタンスメソッドコール

Adderオブジェクトが生成出来たので、次はaddメソッドをコールする部分です。

         8: aload_1
         9: iconst_2
        10: iconst_3
        11: invokevirtual #10   // Method add:(II)I
        14: istore_2

インスタンスメソッドをコールするには、コールするメソッドのオブジェクトとメソッドの引数をオペランドスタックに積んでおきます。

まず、aload_1でローカル変数のインデックス1にあるAdderオブジェクトを積みます。

 

9行と10行のiconstは、定数をスタックに積むオペコードです。接尾語の_2と_3がスタックに積む値を示しています。

 

constの接尾語は-1から5までなので、これを超える数にするとどうなるでしょう。

byte型の範囲であればbipush、short型の範囲であればsipush、それを超える場合はldcが使われます。

たとえば、adder(128, 1_000_000);とすると、バイトコードは次のように変化します。

         8: aload_1
         9: sipush        128
        12: ldc           #10                 // int 1000000
        14: invokevirtual #11                 // Method add:(II)I
        17: istore_2

 

128にはsipush、1,000,000にはldcでコンスタントプールの値が使われています。

 

メソッドのターゲットとなるオブジェクトと引数をオペランドスタックに積んだ後に、インスタンスメソッドをコールするinvokevirtualを実行します。

どのメソッドをコールするのかは、コンスタントプールの#10に記述されています。

Adderクラスのデフォルトコンストラクターと同じようにコンスタントプールをたどっていくと、Adder.add(II)Iになることが分かります。

(II)が引数が2つで両方ともint、最後のIで戻り値の型もintだということを示しています。

invokevirtualを実行すると、mainメソッドのフレームは一時停止し、新たにaddメソッドのフレームがJVMスタックに積まれ、addメソッドの実行が始まります。

 

addメソッドの実行は前回紹介したので、ここでは省略します。

addメソッドの実行が完了すると、addメソッドのフレームは取り除かれ、addメソッドの戻り値がmainメソッドのフレームのオペランドスタックに積まれます。

 

後は、その値をistore_2を使用してローカル変数配列のインデックス2に格納します。

 

ローカル変数配列のインデックス2はresult変数を表しているので、addメソッドをコールしてresultに代入するJavaのコードが完了したことになります。

 

最後のSystem.out.printlnメソッドもインスタンスメソッドなので、メソッドコールの方法はaddメソッドの場合と同じです。

少しだけ違うのが、printlnメソッドのターゲットとなるオブジェクトのSystem.outです。

System.outはSystemクラスのクラス変数(static変数)であるoutです。

このため、System.outを取得するために、オペコードのgetstaticを使用します。

15行のgetstatic #14がその部分です。

コンスタントプールの#14を見てみると、次のようになっています。

  #14 = Fieldref           #15.#16        // java/lang/System.out:Ljava/io/PrintStream;
  #15 = Class              #17            // java/lang/System
  #16 = NameAndType        #18:#19        // out:Ljava/io/PrintStream;
  #17 = Utf8               java/lang/System
  #18 = Utf8               out
  #19 = Utf8               Ljava/io/PrintStream;

 

#14がFieldrefでフィールドの参照を示していることが分かります。その値が#15.#16です。

#15の方がフィールドのクラス、#16がフィールド名と型を表します。

さらにたどっていくと、#15がjava.lang.Systemを指していることが分かります。

#16はNameAndTypeで、#18がフィールド名、#19が型を表しています。#18には文字列定数でout、#19も文字列定数でLjava/io/PrintStreamとなっています。

今まで、Iがint、voidがVだということは出てきました。プリミティブ型ではなく参照型の場合、接頭語としてLが使用され、その後にパッケージを含めたクラス名が続きます。

Aではなくて、Lになることにご注意ください。

これで、getstaticでSystem.outの参照がオペランドスタックに積まれることが分かりました。

後は、addメソッドと同じように引数もオペランドスタックに積んで、invokevirtualを実行します。

 

mainメソッドにはreturn文の記述はありませんが、実際には省略されているだけでreturn文は必ずあります。

25行のreturnがそれに相当します。mainメソッドに戻り値はないので、接頭辞はないreturnを使用します。

returnを実行すると、mainメソッドのフレームが破棄され、Adderクラスの実行が完了します。

 

まとめ

Javaだと高々数行のコードですが、バイトコードで見てみるとJavaのコードを細かく分解して実行されます。

ここで示したように、メソッド単位でフレームが作られ、その内部でオペランドスタックとローカル変数配列で処理を進めていくのです。

さて、次回はif文やforループなどの制御構造について紹介する予定です。

2025/04/01

バイトコード入門 その4 バイトコード処理の基礎

このエントリーをはてなブックマークに追加

Java 24のリリース関連エントリーが続きましたが、再びバイトコード入門に戻ってきました。

今回はJVMスタックに積まれたフレームでどのようにバイトコードを処理するのか紹介していきます。今回は動作を説明するため、個々の命令についての説明は必要最低限とさせていただきます。

  1. 準備編
  2. スタックマシン
  3. バイトコード処理の構成
  4. バイトコード処理の基礎 (今回)

 

バイトコード処理構成のおさらい

まず、バイトコードを処理する構成について簡単におさらいしておきましょう。

バイトコードを実行するために、JVMスタックが使用されるということを前回説明しました。

JVMスタックはスレッドごとに作成されます。ここでのスレッドはOSのスレッドと1対1に対応するPlatform Threadを指しています。Virtual ThreadはPlatform Thread上で動作するので、Virtual Thread用にJVMスタックが作られることはありません。

JVMスタックには、メソッドコールごとにフレームが積まれます。

たとえば、mainメソッドからfooメソッドがコールされ、fooメソッドからbarメソッドがコールされて、barメソッドを処理している場合、JVMスタックにはmainメソッドのフレーム、fooメソッドのフレーム、barメソッドのフレームという3つのフレームが積まれます。

barメソッドの処理が完了し、fooメソッドに戻ってきた時点でbarメソッドのフレームもJVMスタックから取り除かれます。

 

フレームは主にローカル変数用配列と、バイトコード処理中のデータを保持するオペランドスタックから構成されます。

いずれもそのサイズはjavacコンパイル時に決定します。

 

バイトコード処理

今回は動作だけを説明するので、とても簡単なアプリケーションを使用しましょう。

Adderクラスは整数の足し算をするメソッドaddメソッドを持つクラスです。

public class Adder {
    public int add(int x, int y) {
        int z = x + y;
        return z;
    }

    public void static main(String... args) { 
        Adder adder = new Adder();
        int result = adder.add(2, 3);
        System.out.println(result);
    }
}

 

このプログラムが実行されると、メインスレッドに対応するJVMスタックが生成されます。そして、mainメソッドがコールされて、JVMスタックにもmainメソッドに対応するフレームが積まれます。

mainメソッドの中でaddメソッドがコールされると、JVMスタックにもaddメソッドに対応するフレームが積まれます。

この状態を表したのが、以下の図です。

 

では、addメソッド実行の様子を追っていきましょう。

 

addメソッドのバイトコード

Adderクラスをデバッグオプションの-gを使用してコンパイルし、javapでaddメソッドを調べたのが以下です(-gオプションについては、前回を参照してください)。

  private int add(int, int);
    descriptor: (II)I
    flags: (0x0002) ACC_PRIVATE
    Code:
      stack=2, locals=4, args_size=3
         0: iload_1
         1: iload_2
         2: iadd
         3: istore_3
         4: iload_3
         5: ireturn
      LineNumberTable:
        line 3: 0
        line 4: 4
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       6     0  this   LAdder;
            0       6     1     x   I
            0       6     2     y   I
            4       2     3     z   I

ここで使用されているオペコード(命令)を簡単に説明しておきましょう。

  • iload: int型の整数をローカル変数配列からオペランドスタックに積む。_の後の数字はローカル変数配列のインデックス
  • iadd: int型の加算
  • istore: オペランドスタックの先頭にあるint型整数を取り出し、ローカル変数配列に格納。_の後の数字はローカル変数配列のインデックス
  • ireturn: オペランドスタックの先頭にあるint型整数を戻り値としてメソッドを完了させる

この後に実際の動きを説明するので、ここではそんなものぐらいに思っておいてください。

 

addメソッドの動作

では、オペランドスタックとローカル変数配列を含めて、addメソッドの動作を追っていきます。

addメソッドがコールされると、引数がローカル変数配列に格納されます。また、インスタンスメソッドの場合、暗黙の引数としてthisが渡され、それも一緒にローカル変数配列に置かれます。

addメソッドを引数としてx=2, y = 3でコールされた直後の様子は次のようになります。

 

 

ローカル変数配列のインデックス0にthis、1にxの値である2、2にyの値である3が入ります。

上図では分かりやすさのため、ローカル変数配列にx、y、zを記述してありますが、実際にはローカル変数名はコンパイル時に削除され、インデックスだけで扱われます。

ただし、前回説明したようにコンパイル時に-gオプションをつければ、LocalVariableTableが付随し、インデックスと変数名の対応が付けられるようになります。

 

はじめのiload_1はローカル変数配列のインデックス1の値をオペランドスタックに積むということです。iloadのiはint型を表しています。i以外にも接頭辞はありますが、それは次回説明することにします。

この結果、オペランドスタックには2が積まれます。

 

同様に、iload_2でオペランドスタックに3が積まれます。

 

次のiaddはint型の加算です。

ここでは、「バイトコード入門その2」で示したHPの電卓のように、演算に必要な個数だけ値をスタックから取り出し、結果をスタックに積みます。

加算の場合、演算に必要な値は2つなので、オペランドスタックに積まれていた3と2を取り出し、加算をした結果の5をオペランドスタックに積みます。

 

加算の結果はオペランドスタックにしかないので、オペランドスタックから値を取り出し、ローカル変数配列に収めるのが、次の行のistore_3です。

istore_3なので、配列のインデックス3の場所に加算結果の5を格納します。

この操作が、ローカル変数zに5を代入していることに相当します。

 

残りはJavaのコードのreturn z;の部分です。

iload_3で再び5をオペランドスタックに積みます。

 

そして、オペランドスタックに積んだ値を戻り値として、メソッドを完了させるのがireturnです。

ireturnが完了すると、addメソッドに相当するフレームは削除されます。

 

これでaddメソッドが完了しました。

このaddメソッドはとても単純なメソッドですが、オペランドスタックとローカル変数配列の使い方は変わらないので、これが理解できれば後はそれほど難しいことはないはずです。

ちなみに、最後のストアとロードが不要のように見えるかもしれませんが、気にしない方がよいです。

もし、このメソッドが何度もコールされるようであればHotSpot VMによって最適化されます。

javacでコンパイルした時点では最適化はされずに、本当に必要であれば実行時に最適化されるのです。

 

次回はメソッドコールやオブジェクト生成など、もうちょっと複雑なバイトコードを紹介していきます。また、if文やループなども紹介する予定です。

2025/03/18

JEPで語るJava 24

このエントリーをはてなブックマークに追加

いつもはJEPで語れないだけですが、前回のエントリーで紹介したようにJava 24のAPIの変更はとても少なく、逆にJEPは24もあります。

そこで、今回はJava 24は24のJEPについて簡単に紹介していきます。

反応がよければ、シリーズ化するかも。

前回もリストアップしましたが、Java 24のJEPは以下の通り24になります。

  • 404: Generational Shenandoah (Experimental)
  • 450: Compact Object Headers (Experimental)
  • 472: Prepare to Restrict the Use of JNI
  • 475: Late Barrier Expansion for G1
  • 478: Key Derivation Function API (Preview)
  • 479: Remove the Windows 32-bit x86 Port
  • 483: Ahead-of-Time Class Loading & Linking
  • 484: Class-File API
  • 485: Stream Gatherers
  • 486: Permanently Disable the Security Manager
  • 487: Scoped Values (Fourth Preview)
  • 488: Primitive Types in Patterns, instanceof, and switch (Second Preview)
  • 489: Vector API (Ninth Incubator)
  • 490: ZGC: Remove the Non-Generational Mode
  • 491: Synchronize Virtual Threads without Pinning
  • 492: Flexible Constructor Bodies (Third Preview)
  • 493: Linking Run-Time Images without JMODs
  • 494: Module Import Declarations (Second Preview)
  • 495: Simple Source Files and Instance Main Methods (Fourth Preview)
  • 496: Quantum-Resistant Module-Lattice-Based Key Encapsulation Mechanism
  • 497: Quantum-Resistant Module-Lattice-Based Digital Signature Algorithm
  • 498: Warn upon Use of Memory-Access Methods in sun.misc.Unsafe
  • 499: Structured Concurrency (Fourth Preview)
  • 501: Deprecate the 32-bit x86 Port for Removal

JEPで語れないシリーズでもそうですが、セキュリティ関連のJEP (JEP 478, JEP496, JEP 497)はさくらばがよく分かっていないので、省略します。

 

JEP 404 Generational Shenandoah (Experimental)

ShenandoahはRed Hatが中心となって作られているGCです。

Shenandoahはオブジェクトの世代を使用せずにGCを行うアルゴリズムでしたが、ZGCと同様に世代別GCを導入することになったようです。

Experimentalなのですぐに世代別GCを正式に導入するわけではないですが、次の次のLTSには世代別GCが正式になっていると思われます。

後ほど紹介しますが、ZGCは世代別GCだけを残すことになりました。今後、Shenandoahはどうするんでしょうね。

 

さて、世代別GCを使う方法です。

以下の実行時オプションを3つ指定します。

  • -XX:+UnlockExperimentalVMOptions
  • -XX:+UseShenandoahGC
  • -XX:ShenandoahGCMode=generational

ただし、Oracle OpenJDKやOracle JDKはShenandoah GCを含まないので、Red Hat JDKやEclipse Temurinなどを使ってみてください。

 

JEP 450 Compact Object Headers (Experimental)

Javaのオブジェクトはヒープに配置されますが、オブジェクトにはヘッダーがつきます。

オブジェクトヘッダーはJVMの実装依存の部分なのでJVMSには定義されていないのですが、HotSpot VMの場合ヘッダーに128bit使用します。

しかし、小さいクラスだとヘッダーがバカになりません。

たとえば、record Point(int x, int y) {} なんていうクラスだと、データとしては8byte (64bit)しかありません。こうなると、ヘッダーの方が大きくなってしまうわけです。

そこで、現状128bitあるオブジェクトヘッダーを小さくするために立ち上がったのがProject Lilliputです。

Project LeadはAmazonのRoman Kennkeさん。数少ないOracleがリードではないプロジェクトです。

彼はJVMLSでProject Lilliputの講演をしているのですが、Lilliputの背景や概要についてはJVMLS 2023の講演が参考になると思います。

 

ちなみに、プロジェクト名のLilliputですが、ガリバー旅行記の出てくる小人の国のリリパット王国のことです。

なかなかいいプロジェクト名だと思いませんか?

 

Project Lilliputは、64bit VMと32bit VMの両方に対応していますが、ここでは64bit VMについて説明します。

オブジェクトヘッダーには以下のような情報が保持されます。

  • GC Age
  • 型(クラス)
  • ロック
  • ハッシュコード

GC Ageというのは、オブジェクトがGCから生き残ってきた回数を表します。世代別GCの場合、このAgeによってオブジェクトをYoung領域からOld領域に移動させます。

64bit VMではオブジェクトヘッダーが128bitで、上位64bitと下位64bitに分割されて使用されます。

上位64bitはマークワードと呼ばれ、ハッシュコード、GC Age、ロック情報が格納されます。ロック情報は下図のTagビットで表されます。

Mark Word (normal):
 64                     39                              8    3  0
  [.......................HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH.AAAA.TT]
         (Unused)                      (Hash Code)     (GC Age)(Tag)

 

下位64bitはクラスワードと呼ばれ、クラスポインターが格納されます。

Class Word (uncompressed):
64                                                               0
 [cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]
                          (Class Pointer)

 

これに対し、Project Lilliputでは以下のようにヘッダーを64bitに抑えます。

Header (compact):
64                    42                             11   7   3  0
 [CCCCCCCCCCCCCCCCCCCCCCHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHVVVVAAAASTT]
 (Compressed Class Pointer)       (Hash Code)         /(GC Age)^(Tag)
                              (Valhalla-reserved bits) (Self Forwarded Tag)

 

これが実現されれば、多量のオブジェクトを使うシステムではかなりヒープ使用量が減るはずです。

ただし、ちょっと分からない部分もあります。上図のValhalla-reserved bitsです。

これはValue Class用のビットです。Value Objectはヒープの平坦化がされれば、オブジェクトヘッダーを使用しません。しかし、平坦化されない場合は通常のオブジェクトと同様にヘッダーを使用します。

この場合、通常のオブジェクトとValue Objectを区別するために上記のビットが使われることになると思われます。

Value Classが正式化されるまで、Previewのままなのか、それとも見切り発車で進んでしまうのか、どちらなんでしょうね。

 

Compact Object Headerを使用するには以下の2つの実行時オプションを使用します。

  • -XX:+UnlockExperimentalVMOptions
  • -XX:+UseCompactObjectHeaders

 

472: Prepare to Restrict the Use of JNI
498: Warn upon Use of Memory-Access Methods in sun.misc.Unsafe

最近、OpenJDKではIntegrityがトピックになっています。

Integrityの意味は「誠実さ」とか「正直さ」などです。JavaでIntegrityってよく分からないですよね。

JavaのAPIや機能、ツールなどには黒魔術とも呼べるような安全ではない使い方ができるものがあります。

しかし、安全で堅牢なシステムを作成するにあたっては、このような機能は徐々に取り除いていかないとダメだよねというのが、JEP draft: Integrity by Defaultです。

また、このJEPの背景を語るドキュメントとしてPeaceful and Bright Future of Integrity by Default in Javaがあります。ありがたいことに、このドキュメントは西川さんが翻訳してくれています。

このJEPはまだdraftなので今後どうなるか分からないのですが、Java 24でもIntegrity by Defaultに関連したJEPがあります。それが、JEP 472とJEP 498です。

JEP 472がJNIの使用を制限するJEPで、JEP 498がsun.misc.Unsafeの使用を制限するというJEPです。

特にUnsafeはいろいろと危険なことができてしまっていたのですが、徐々に機能が減らされていって、最後に残っていたのがネイティブメモリへのアクセスだったのです。これに対し、安全にメモリにアクセス可能なFFMが提供されたので、ようやくUnsafeがお役御免となったわけです。まだ、Unsafeを使用すると警告が出るだけですが、だんだんと使えなくなっていくはずです。

 

475: Late Barrier Expansion for G1

G1GCの実装を改善しましょうというJEP。

バリアは何かしらを守るために使用される、同期方法の一種です。たとえば、CPUでメモリ操作の順序性を保証するために使われるメモリバリアなどがあります。

G1GCでもプリライトバリアやポストライトバリアなどのバリアが使われるのですが、そのバリアの処理が重いので、特にJITのC2コンパイラ使用時に改善していきましょうという提案です。

これはStandard JEPで、特に指定しなくてもG1GCを使用時には適用されます。

このJEPに関してThomas Schatzlが解説を書いてくれています。ありがたいことに、西川さんが翻訳してくれています。

 

479: Remove the Windows 32-bit x86 Port
486: Permanently Disable the Security Manager
501: Deprecate the 32-bit x86 Port for Removal

Integrity by Defaultとは関係ないのですが、機能を削除する関連のJEPがJEP 479、JEP 486、JEP 501です。

JEP 479とJEP 501は32bitのx86のポートを削除するJEPで、JEP 486が使わなくなったSecurity Managerを削除するJEPです。

 

483: Ahead-of-Time Class Loading & Linking

Javaは起動時間が遅いとよく言われますが、それを改善するためのプロジェクトがProject Leydenです。

Leydenとはライデン瓶のライデンですね。ライデン瓶は一種のコンデンサーで、導通した時に一気に電気を流せることからプロジェクト名になったんだと思います。あくまでも、櫻庭の予想ですが...

さて、Project LeydenではAOTコンパイラーが提供される予定ですが、その前にJEP 483で事前クラスローディングやリンクを可能とします。

 

Javaの起動時には様々な処理が行われます。その中でも、クラスロードし、クラスの解析、リンク、staticの初期化までの処理はシステムが大規模になればなるほど長い時間を必要とします。また、システムによっては、実行時アノテーションの解決も必要になります。

しかし、これらの処理は毎回同じことを繰り返すだけなので、その部分を事前にやってしまおうというのがJEP 483です。

実際には、トレーニング実行でこれらの処理をキャッシュとして保存しておき、本番時にはキャッシュを使用してシステムを起動します。

キャッシュファイルをapp.aotconfとした場合、以下のようにトレーニング実行、キャッシュファイルの保存という2段階でキャッシュファイルを作成します。

  • トレーニング実行
    $ java -XX:AOTMode=record -XX:AOTConfiguration=app.aotconf -cp app.jar com.example.App ...
  • キャッシュファイル作成
    $ java -XX:AOTMode=create -XX:AOTConfiguration=app.aotconf -XX:AOTCache=app.aot -cp app.jar

2番目のキャッシュファイル作成時にはアプリケーションは実行しません。

キャッシュファイルができたら、それを使用して実行します。

  • 本番実行
    $ java -XX:AOTCache=app.aot -cp app.jar com.example.App ...

 

484: Class-File API

Class-File APIはバイトコード操作のためのAPIです。

クラスファイルを解析したり、バイトコードで記述して直接クラスファイルを生成したりすることができます。

JDKの内部では動的にクラスを生成する場合などにバイトコード操作が行われてきました。この時に使用されていたのが、ASMです。

では、なぜ今になってASMではなくて、自前のバイトコード操作APIを作成することになったのでしょう。

クラスファイルにもバージョンがあり、バージョンが上がるごとに記述できる情報が増えていっています。しかし、サードパーティーのASMだと、最新のバージョンをサポートするまでに時間がかかってしまいまいます。

新しいクラスファイルをすぐにサポートするためには、やはり自前でバイトコード操作APIを作らないとダメということのようです。

 

Class-File APIでは、クラスファイルの読み、書き、改変をサポートしています。また、ストリーミング的な使い方と、イベント的な使い方の両方ができるようになっています。XMLでいうところのSAXとDOMのような使い分けができるはずです。

 

Class-File APIに関しては、今続けているバイトコード入門の続きとして紹介する予定です。

また、JJUGのナイトセミナーで少しだけ紹介したので、参考までに資料を張っておきます。

 

485: Stream Gatherers

Stream APIの中間操作をカスタマイズできるようにするのがStream Gathererです。

Stream Gathererに関しては、すでに解説エントリーを書いているので、そちらを参照してみてください。

 

487: Scoped Values (Fourth Preview)

Project Loomで策定されているAPIの1つであるScoped Valueはスレッド間でイミュータブルなデータを共有するための機能です。

今まで使用してきたThreadLocalはいろいろと問題があるので、それを全部ではないですけど、ある程度置き換えられる機能になっています。

4th PreviewでなかなかStandardにならないですが、次のJava 25でStandardになればいいかなという感じですね。

Java 24では1つだけメソッドが削除されて、一貫性のある使い方に整理されたようです。

 

488: Primitive Types in Patterns, instanceof, and switch (Second Preview)

パターンマッチングにプリミティブ型を使用できるようにしようというのがJEP 488です。

これのおもしろいのが、プリミティブ型の値とのマッチングと、型とのマッチングを同居させることができるところです。たとえば、こういう記述ができます。

switch(x) {
    case 0 -> System.out.println("Zero");
    case 1 -> System.out.println("One");
    case int i when i > 100 -> System.out.println("Big int: " + i);
    case int i -> System.out.println("Small int: " + i);
}

いろいろとルールはあるので、細かいところはJEP 488を読んでみてください。

 

489: Vector API (Ninth Incubator)

Javaでベクター処理を行うためのVector APIですが、Value Classが導入されるまではずっとインキュベータのままということになっています。

 

490: ZGC: Remove the Non-Generational Mode

ZGCはJava 23で世代別ZGCがデフォルトになりましたが、そうそうに元々の非世代別ZGCが削除されることになりました。

世代別と非世代別の両方をサポートするのは大変なのは分かりますが、そこまで急いで削除しなくてもいいのではと思ってしまいます。

 

491: Synchronize Virtual Threads without Pinning

Virtual Threadの使用時にsynchronizedを使うと、Virtual Threadを実行するキャリアスレッドをブロックしてしまうため性能が落ちるという問題がありました。

そのため、Virtual Threadを使う時にはsynchronizedではなく、ReentrantLockを使うようにしましょうというのが今までの解決法でした。

これに対し、synchronizedを使ってもキャリアスレッドをブロックしないようにするのがJEP 491です。

とはいえ、JEP 491が導入されれば、Virtual Threadでもsynchronizedを書き放題と思うのは早計です。

synchnronizedでもReentrantLockでも同期をするためにVirtual Threadをブロックします。キャリアスレッドのブロックよりはいいかもしれませんが、ブロックはブロックです。

Virtual Threadを使うようなスケールでは、些細なブロックでもできれば避けた方が賢明です。

ライブラリやフレームワークでsynchornizedを使用しているため、今までVirtual Threadを使っていても性能が出なかったという場合であればよいのですが、新たにVirtual Threadを使うコードを記述するのであれば、なるべくスレッドを独立にしてブロックしないような設計にするのがよいと思います。

 

492: Flexible Constructor Bodies (Third Preview)

コンストラクター内でスーパークラスや自分自身のコンストラクターをコールするのは、コンストラクターの先頭と決まっていました。

これに対し、フィールドの初期化の後にも書けるようにしたのがJEP 492です。

なぜこんなことが必要なのかというのと、Project Valhallaが関係しています。

Project ValhallaではValue Classの導入と、その効率化のためにNull非許容な型が導入されます。

しかし、コンストラクター内でスーパークラスのコンストラクターを先頭でコールしてしまうと、フィールドが初期化されていない状態でスーパークラスから参照できてしまいます。これはNull非許容の場合だと問題になります。

そのため、Value ClassやNull非許容型が導入される前に、JEP 492で問題となりそうな箇所をつぶしておこうというわけです。

Java 23の3rd Previewからの変更点はないので、Java 25ではStandardになるはずです。

 

493: Linking Run-Time Images without JMODs

JDKの標準ライブラリーはモジュール構成になっており、JARではなくJMODで提供されています。

当然、jlinkでランタイムを作成する場合もJMODがそのまま使われていました。これに対し、モジュールのJARでも可能にするようにしたのがJEP 493です。

 

494: Module Import Declarations (Second Preview)

import文にモジュール単位で記述できるようにするのがJEP 494です。

import module java.base;と書いておけば、java.langパッケージやjava.utilパッケージのクラスやインタフェースのimport文を書かずに済みます。

モジュール間で同じクラス名を使用している場合、明示的に優先的に使用するクラスのimport文を記述します。

たとえば、java.baseとjava.desktopをインポートしてしまうと、java.util.Listとjava.awt.Listなどの同じ名前のクラス/インタフェースをインポートしてしまいます。java.util.Listを優先的に使うのであれば、次のように記述します。

import module java.base;
import module java.base;

import java.util.List;

 

495: Simple Source Files and Instance Main Methods (Fourth Preview)

JEP 495は、mainメソッドの記述を簡素化するためのJEPです。

mainメソッドのためのクラスを書く必要がなくなり、void main() { ... }だけでOKになります。

また、標準出力への出力もSystem.out.println(...);ではなく、println(...);だけでよくなります。

このJEPもなかなかStandardになりませんが、Java 24での変更点はないので、このままJava 25でStandardになると予想されます。

 

499: Structured Concurrency (Fourth Preview)

JEP 499はProject Loomで策定されている仕様の1つです。

複数のスレッドの結果をまとめるためのAPIで、すべての処理結果を待つことや、失敗が1つでもあったら処理を失敗とするなどといったことが簡単に記述できます。

今までであれば、CompletableFutureを使えば同じようなことを記述できるのですが、Thread単体だとちょっと面倒でした。

そこで、Virtual Threadの導入とともにStructured Concurrencyが導入されるはずだったのですが、なかなかStandardにならないまま...

しかし、Java 24での変更はないので、Java 25でStandardになるのではないかと思うのですが、どうでしょう。

 

まとめ

というわけで、セキュリティ関連を除いてJava 24のJEPを簡単に紹介してきました。

最後の方はかなり簡単な紹介だけになってしまいましたが...

PreviewやIncubatorのJEPはStandardになった時に改めて紹介したいと思います。