O bloco Try-Finalmente impede StackOverflowError

Dê uma olhada nos dois métodos a seguir:

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

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

A execução bar()resulta claramente em a StackOverflowError, mas a execução foo()não (o programa parece funcionar indefinidamente). Por que é que?

Não dura para sempre. Cada estouro de pilha faz com que o código seja movido para o bloco final. O problema é que levará muito, muito tempo. A ordem do tempo é O (2 ^ N), em que N é a profundidade máxima da pilha.

Imagine a profundidade máxima é 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()

Para trabalhar cada nível no bloco final, demore o dobro do tempo que a profundidade da pilha possa ser 10.000 ou mais. Se você puder fazer 10.000.000 de chamadas por segundo, isso levará 10 ^ 3003 segundos ou mais que a idade do universo.

Quando você receber uma exceção da invocação de foo()dentro do try, você chama foo()de finallye começar a recursão novamente. Quando isso causa outra exceção, você liga foo()de outro interno finally(), e assim por diante quase ad infinitum .

Tente executar o seguinte código:

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

Você descobrirá que o bloco finalmente é executado antes de lançar uma exceção no nível acima dele. (Resultado:

Finalmente

Exceção no encadeamento "main" java.lang.Exception: TEST! em test.main (test.java:6)

Isso faz sentido, como finalmente é chamado logo antes de sair do método. Isso significa, no entanto, que assim que você obtê-lo primeiro StackOverflowError, ele tentará lançá-lo, mas o finalmente deve ser executado primeiro, para que seja executado foo()novamente, o que causa um estouro de outra pilha e, como tal, é executado finalmente novamente. Isso continua acontecendo para sempre, portanto a exceção nunca é realmente impressa.

No seu método de barra, no entanto, assim que a exceção ocorre, ela é lançada diretamente para o nível acima e será impressa

Em um esforço para fornecer evidências razoáveis ​​de que isso acabará eventualmente, ofereço o seguinte código bastante sem sentido. Nota: Java NÃO é minha linguagem, por qualquer trecho da imaginação mais vívida. Eu ofereço isso apenas para apoiar a resposta de Peter, que é a resposta correta para a pergunta.

Isso tenta simular as condições do que acontece quando uma chamada NÃO pode acontecer porque introduziria um estouro de pilha. Parece-me a coisa mais difícil que as pessoas não conseguem entender, pois a invocação não acontece quando não pode acontecer.

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+")");
        }
    }
}

A saída dessa pequena pilha inútil de gosma é a seguinte, e a exceção real capturada pode ser uma surpresa; Ah, e 32 tentativas (2 ^ 5), o que é totalmente esperado:

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)

Aprenda a rastrear seu programa:

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

Esta é a saída que vejo:

[...]
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
[...]

Como você pode ver, o StackOverFlow é lançado em algumas camadas acima, portanto, você pode executar etapas de recursão adicionais até encontrar outra exceção, e assim por diante. Este é um "loop" infinito.

O programa simplesmente parece funcionar para sempre; na verdade, termina, mas leva exponencialmente mais tempo quanto mais espaço de pilha você tiver. Para provar que termina, escrevi um programa que primeiro esgota a maior parte do espaço disponível na pilha, depois chama fooe, finalmente, grava um rastro do que aconteceu:

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)
    ...

O código:

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);
      }
    });
  }
}

Você pode experimentá-lo online! (Algumas execuções podem ser feitas foomais ou menos vezes que outras)