Java における例外のパフォーマンスへの影響は何ですか? 質問する

例外がどのように実装されるかによって異なります。最も簡単な方法は、setjmp と longjmp を使用することです。つまり、CPU のすべてのレジスタがスタックに書き込まれ (すでに時間がかかります)、他のデータも作成する必要があります... これらはすべて try ステートメントですでに行われています。throw ステートメントはスタックを巻き戻し、すべてのレジスタの値 (および VM 内のその他の値) を復元する必要があります。したがって、try と throw は同じように遅く、かなり遅いですが、例外がスローされない場合は、ほとんどの場合、try ブロックを終了するのにまったく時間がかかりません (すべてがスタックに配置され、メソッドが存在する場合は自動的にクリーンアップされるため)。

Sun やその他の企業は、これがおそらく最適ではないことを認識しており、もちろん VM は時間の経過とともにどんどん高速化しています。例外を実装する別の方法があり、これにより try 自体が非常に高速になり (実際には try ではまったく何も起こりません。クラスが VM によってロードされたときに、必要なことはすべて既に完了しています)、throw がそれほど遅くならなくなります。どの JVM がこの新しい、より優れた手法を使用しているかはわかりません...

...しかし、Java でコードを記述すると、後で特定のシステム上の 1 つの JVM でのみ実行されますか? 他のプラットフォームまたは他の JVM バージョン (他のベンダーの可能性もあります) で実行される可能性がある場合、高速実装も使用すると誰が言うでしょうか? 高速実装は低速実装よりも複雑で、すべてのシステムで簡単に実現できるわけではありません。移植性を維持したいですか? 例外が高速であることに頼らないでください。

try ブロック内で何を行うかによっても大きな違いが生じます。try ブロックを開いて、この try ブロック内からメソッドを呼び出さない場合、JIT は throw を単純な goto のように扱うことができるため、try ブロックは非常に高速になります。例外がスローされた場合、スタック状態を保存する必要も、スタックをアンワインドする必要もありません (catch ハンドラーにジャンプするだけで済みます)。ただし、これは通常行うことではありません。通常は try ブロックを開いてから、例外をスローする可能性のあるメソッドを呼び出します。また、メソッド内で try ブロックを使用する場合でも、他のメソッドを呼び出さないメソッドとはどのようなメソッドでしょうか。数値を計算するだけでしょうか。では、例外は何のために必要なのでしょうか。プログラム フローを制御するはるかにエレガントな方法があります。単純な計算以外のほとんどの操作では、外部メソッドを呼び出す必要があり、これでローカル try ブロックの利点が失われます。

次のテストコードを参照してください。

public class Test {
    int value;


    public int getValue() {
        return value;
    }

    public void reset() {
        value = 0;
    }

    // Calculates without exception
    public void method1(int i) {
        value = ((value + i) / i) << 1;
        // Will never be true
        if ((i & 0xFFFFFFF) == 1000000000) {
            System.out.println("You'll never see this!");
        }
    }

    // Could in theory throw one, but never will
    public void method2(int i) throws Exception {
        value = ((value + i) / i) << 1;
        // Will never be true
        if ((i & 0xFFFFFFF) == 1000000000) {
            throw new Exception();
        }
    }

    // This one will regularly throw one
    public void method3(int i) throws Exception {
        value = ((value + i) / i) << 1;
        // i & 1 is equally fast to calculate as i & 0xFFFFFFF; it is both
        // an AND operation between two integers. The size of the number plays
        // no role. AND on 32 BIT always ANDs all 32 bits
        if ((i & 0x1) == 1) {
            throw new Exception();
        }
    }

    public static void main(String[] args) {
        int i;
        long l;
        Test t = new Test();

        l = System.currentTimeMillis();
        t.reset();
        for (i = 1; i < 100000000; i++) {
            t.method1(i);
        }
        l = System.currentTimeMillis() - l;
        System.out.println(
            "method1 took " + l + " ms, result was " + t.getValue()
        );

        l = System.currentTimeMillis();
        t.reset();
        for (i = 1; i < 100000000; i++) {
            try {
                t.method2(i);
            } catch (Exception e) {
                System.out.println("You'll never see this!");
            }
        }
        l = System.currentTimeMillis() - l;
        System.out.println(
            "method2 took " + l + " ms, result was " + t.getValue()
        );

        l = System.currentTimeMillis();
        t.reset();
        for (i = 1; i < 100000000; i++) {
            try {
                t.method3(i);
            } catch (Exception e) {
                // Do nothing here, as we will get here
            }
        }
        l = System.currentTimeMillis() - l;
        System.out.println(
            "method3 took " + l + " ms, result was " + t.getValue()
        );
    }
}

method1 took 972 ms, result was 2
method2 took 1003 ms, result was 2
method3 took 66716 ms, result was 2