try-finallyブロックはStackOverflowErrorを防ぎます

次の2つの方法を見てください。

public static void foo() {
    try {
        foo();
    } finally {
        foo();
    }
}

public static void bar() {
    bar();
}

実行するbar()と明らかに結果はになりますStackOverflowErrorが、実行されfoo()ません（プログラムが無期限に実行されるように見えるだけです）。何故ですか？

それは永遠に実行されません。スタックオーバーフローが発生するたびに、コードはfinallyブロックに移動します。問題は、本当に長い時間がかかることです。時間の順序はO（2 ^ N）で、Nは最大スタック深度です。

最大深度が5だと想像してください

foo() calls
    foo() calls
       foo() calls
           foo() calls
              foo() which fails to call foo()
           finally calls
              foo() which fails to call foo()
       finally
           foo() calls
              foo() which fails to call foo()
           finally calls
              foo() which fails to call foo()
    finally calls
       foo() calls
           foo() calls
              foo() which fails to call foo()
           finally calls
              foo() which fails to call foo()
       finally
           foo() calls
              foo() which fails to call foo()
           finally calls
              foo() which fails to call foo()
finally calls
    foo() calls
       foo() calls
           foo() calls
              foo() which fails to call foo()
           finally calls
              foo() which fails to call foo()
       finally
           foo() calls
              foo() which fails to call foo()
           finally calls
              foo() which fails to call foo()
    finally calls
       foo() calls
           foo() calls
              foo() which fails to call foo()
           finally calls
              foo() which fails to call foo()
       finally
           foo() calls
              foo() which fails to call foo()
           finally calls
              foo() which fails to call foo()

各レベルをfinallyブロックに組み込むには、スタックの深さが10,000以上になる可能性があるので2倍かかります。1秒あたり10,000,000回の呼び出しを行うことができる場合、これには10 ^ 3003秒以上かかるか、宇宙の古さよりも長くなります。

あなたがの呼び出しから例外を取得するとfoo()の内部tryには、呼び出しfoo()からfinallyと再び再帰的に開始します。それによって別の例外が発生した場合はfoo()、別のinnerから呼び出すfinally()など、ほとんど無限に続きます。

次のコードを実行してみてください：

    try {
        throw new Exception("TEST!");
    } finally {
        System.out.println("Finally");
    }

上位レベルまで例外をスローする前に、finallyブロックが実行されることがわかります。（出力：

最後に

スレッド「メイン」の例外java.lang.Exception：TEST！test.main（test.java:6）で

メソッドを終了する直前に最終的に呼び出されるので、これは理にかなっています。ただし、これは、firstを取得StackOverflowErrorすると、それをスローしようとしますが、finallyが最初に実行される必要があるため、foo()再度実行され、別のスタックオーバーフローが発生し、最終的に再び実行されます。これは永久に発生し続けるため、例外が実際に出力されることはありません。

ただし、barメソッドでは、例外が発生するとすぐに、上のレベルまでまっすぐにスローされ、印刷されます。

これが最終的に終了するという合理的な証拠を提供するために、次のかなり意味のないコードを提供します。注：Javaは私の言語ではありません。私は、ピーターの答えは、サポートするためにのみこれを差し出す質問に対する正しい答えを。

これは、スタックオーバーフローが発生するために呼び出しが発生しない場合の状況をシミュレートしようとします。難しいことの人々は、それはときに、invokeが起こらないということで把握するために失敗しているように思えることはできませんが起こります。

public class Main
{
    public static void main(String[] args)
    {
        try
        {   // invoke foo() with a simulated call depth
            Main.foo(1,5);
        }
        catch(Exception ex)
        {
            System.out.println(ex.toString());
        }
    }

    public static void foo(int n, int limit) throws Exception
    {
        try
        {   // simulate a depth limited call stack
            System.out.println(n + " - Try");
            if (n < limit)
                foo(n+1,limit);
            else
                throw new Exception("StackOverflow@try("+n+")");
        }
        finally
        {
            System.out.println(n + " - Finally");
            if (n < limit)
                foo(n+1,limit);
            else
                throw new Exception("StackOverflow@finally("+n+")");
        }
    }
}

この小さな無意味なgooの山の出力は次のとおりです。実際にキャッチされた例外は、驚くかもしれません。ああ、そして完全に予想される32回のtry-calls（2 ^ 5）：

1 - Try
2 - Try
3 - Try
4 - Try
5 - Try
5 - Finally
4 - Finally
5 - Try
5 - Finally
3 - Finally
4 - Try
5 - Try
5 - Finally
4 - Finally
5 - Try
5 - Finally
2 - Finally
3 - Try
4 - Try
5 - Try
5 - Finally
4 - Finally
5 - Try
5 - Finally
3 - Finally
4 - Try
5 - Try
5 - Finally
4 - Finally
5 - Try
5 - Finally
1 - Finally
2 - Try
3 - Try
4 - Try
5 - Try
5 - Finally
4 - Finally
5 - Try
5 - Finally
3 - Finally
4 - Try
5 - Try
5 - Finally
4 - Finally
5 - Try
5 - Finally
2 - Finally
3 - Try
4 - Try
5 - Try
5 - Finally
4 - Finally
5 - Try
5 - Finally
3 - Finally
4 - Try
5 - Try
5 - Finally
4 - Finally
5 - Try
5 - Finally
java.lang.Exception: StackOverflow@finally(5)

プログラムをトレースする方法を学びます。

public static void foo(int x) {
    System.out.println("foo " + x);
    try {
        foo(x+1);
    } 
    finally {
        System.out.println("Finally " + x);
        foo(x+1);
    }
}

これは私が見る出力です：

[...]
foo 3439
foo 3440
foo 3441
foo 3442
foo 3443
foo 3444
Finally 3443
foo 3444
Finally 3442
foo 3443
foo 3444
Finally 3443
foo 3444
Finally 3441
foo 3442
foo 3443
foo 3444
[...]

ご覧のように、StackOverFlowは上のいくつかのレイヤーでスローされるため、別の例外が発生するまで再帰ステップを追加できます。これは無限の「ループ」です。

プログラムは永久に実行されているように見えるだけです。実際には終了しますが、スタックスペースが増えるほど、指数関数的に時間がかかります。それが終了したことを証明するために、利用可能なスタック領域のほとんどを使い果たしてからを呼び出しfoo、最後に何が起こったかのトレースを書き込むプログラムを書きました。

foo 1
  foo 2
    foo 3
    Finally 3
  Finally 2
    foo 3
    Finally 3
Finally 1
  foo 2
    foo 3
    Finally 3
  Finally 2
    foo 3
    Finally 3
Exception in thread "main" java.lang.StackOverflowError
    at Main.foo(Main.java:39)
    at Main.foo(Main.java:45)
    at Main.foo(Main.java:45)
    at Main.foo(Main.java:45)
    at Main.consumeAlmostAllStack(Main.java:26)
    at Main.consumeAlmostAllStack(Main.java:21)
    at Main.consumeAlmostAllStack(Main.java:21)
    ...

コード：

import java.util.Arrays;
import java.util.Collections;
public class Main {
  static int[] orderOfOperations = new int[2048];
  static int operationsCount = 0;
  static StackOverflowError fooKiller;
  static Error wontReachHere = new Error("Won't reach here");
  static RuntimeException done = new RuntimeException();
  public static void main(String[] args) {
    try {
      consumeAlmostAllStack();
    } catch (RuntimeException e) {
      if (e != done) throw wontReachHere;
      printResults();
      throw fooKiller;
    }
    throw wontReachHere;
  }
  public static int consumeAlmostAllStack() {
    try {
      int stackDepthRemaining = consumeAlmostAllStack();
      if (stackDepthRemaining < 9) {
        return stackDepthRemaining + 1;
      } else {
        try {
          foo(1);
          throw wontReachHere;
        } catch (StackOverflowError e) {
          fooKiller = e;
          throw done; //not enough stack space to construct a new exception
        }
      }
    } catch (StackOverflowError e) {
      return 0;
    }
  }
  public static void foo(int depth) {
    //System.out.println("foo " + depth); Not enough stack space to do this...
    orderOfOperations[operationsCount++] = depth;
    try {
      foo(depth + 1);
    } finally {
      //System.out.println("Finally " + depth);
      orderOfOperations[operationsCount++] = -depth;
      foo(depth + 1);
    }
    throw wontReachHere;
  }
  public static String indent(int depth) {
    return String.join("", Collections.nCopies(depth, "  "));
  }
  public static void printResults() {
    Arrays.stream(orderOfOperations, 0, operationsCount).forEach(depth -> {
      if (depth > 0) {
        System.out.println(indent(depth - 1) + "foo " + depth);
      } else {
        System.out.println(indent(-depth - 1) + "Finally " + -depth);
      }
    });
  }
}

あなたはそれをオンラインで試すことができます！（一部の実行はfoo他よりも多くまたは少ない回数を呼び出すかもしれません）