Java中是否可以进行错误恢复

Question

考虑以下生成StackOverflowError的代码。

public class SimpleProgram {
  static SimpleProgram s = new SimpleProgram();
  public static void main(String[] args) {
      s.f(0);
  }
  void f(int i) {
      System.out.println("f :" + (++i));
      g(i);
  }
  void g(int i) {
      System.out.println("g :" + (++i));
      f(i);
  }
}

它只是打印从1到n的数字（当我执行时，用f（）打印'5417'）。之后，它抛出StackOverflowError并终止。现在考虑第二个程序。

public class SimpleProgram{
  static SimplePrograms = new SimpleProgram();
  public static void main(String[] args) {
      s.f(0);
  }
  void f(int i) {
      try {
          System.out.println("f :" + (++i));
          g(i);
      } catch (StackOverflowError e) {
          System.out.println("f :" + (++i));
          g(i);
      }
  }
  void g(int i) {
      try {
          System.out.println("g :" + (++i));
          f(i);
      } catch (StackOverflowError e) {
          System.out.println("g :" + (++i));
          f(i);
      }
  }
}

现在它表现出一些奇怪的行为。程序没有按预期终止，但显示的值会重复（比如f:4107 g:4108到f:4120，然后再次返回f:4107）。

我的问题是，为什么会发生这种情况？我认为像StackOverflowError这样的错误意味着当前线程的堆栈已满，因此无法恢复。程序必须强制停止执行，即不调用下一个函数，但没有发生。JVM线程堆栈是否可以根据需要增加其大小？

Answer 1

您的异常处理程序进行更多的方法调用（对System.out.println()和f()或g()）。这些调用可能会抛出一个新的StackOverflowError，它可能会在调用堆栈的几个级别上被捕获，所以你会看到数字在无限地下降和回升（因为当异常在调用堆栈中的方法中下降时，调用堆栈中会释放一些空间，所以还有空间进行其他调用）。

以下是我得到的部分输出（为了更清楚，我在catch块内的println语句中添加了"catch"）：

第一个StackOverflowError发生在System.out.println(String)尝试调用println()时，这就是为什么g :9662catch g :9663中没有显示新行的原因。出于某种原因，在第一个StackOverflowError之后，还有大约50个额外调用的空间，直到我们得到另一个StackOverflowError，之后错误会更周期性地出现。

... no eception till this point...
g :9660
f :9661
g :9662catch g :9663 
f :9664
g :9665
f :9666
g :9667
f :9668
g :9669
f :9670
g :9671
f :9672
g :9673
f :9674
g :9675
f :9676
g :9677
f :9678
g :9679
f :9680
g :9681
f :9682
g :9683
f :9684
g :9685
f :9686
g :9687
f :9688
g :9689
f :9690
g :9691
f :9692
g :9693
f :9694
g :9695
f :9696
g :9697
f :9698
g :9699
f :9700
g :9701
f :9702
g :9703catch g :9704catch f :9703
g :9704catch g :9705catch g :9702
f :9703
g :9704catch g :9705catch f :9704
g :9705catch g :9706catch f :9701
g :9702
f :9703
g :9704catch g :9705catch f :9704
g :9705catch g :9706catch g :9703
f :9704
g :9705catch g :9706catch f :9705
g :9706catch g :9707catch g :9700
f :9701
g :9702
f :9703
g :9704catch g :9705catch f :9704
g :9705catch g :9706catch g :9703
f :9704
g :9705catch g :9706catch f :9705
g :9706catch g :9707catch f :9702
g :9703
f :9704
g :9705catch g :9706catch f :9705
g :9706catch g :9707catch g :9704
f :9705
....

Answer 2

您所看到的与程序的构建方式有关，而不是与Java处理错误的方式有关。您的程序在每个n调用级别创建两个重试点，因此通过程序的路径总数呈指数级增长。

让我们考虑一下，如果只有三个调用级别足以溢出堆栈，会发生什么：

main -> f(0)
f(0) -> g(0)
g(0) -> f(1)
f(1) -> g(1)
g(1) -> f(2)
f(2) -> g(2)
g(2) -> f(3) <<== Stack overflow

接下来会发生什么？堆栈开始展开。每个方法都为StackOverflowError安装了一个处理程序，因此它们将处理错误并再次调用相同的函数：

g(2) handler -> f(3) <<== Stack overflow #2
f(2) handler -> g(2)
g(2) -> f(3)         <<== Stack overflow #3
g(2) handler -> f(3) <<== Stack overflow #4
g(1) handler -> f(2)
f(2) -> g(2)
g(2) -> f(3)         <<== Stack overflow #5
f(1) handler -> g(1)
g(1) -> f(2)
f(2) -> g(2)
g(2) -> f(3)         <<== Stack overflow #6
g(0) handler -> f(1)
f(1) -> g(1)
g(1) -> f(2)
f(2) -> g(2)
g(2) -> f(3)         <<== Stack overflow #7
f(0) handler -> g(0)
g(0) -> f(1)
f(1) -> g(1)
g(1) -> f(2)
f(2) -> g(2)
g(2) -> f(3)         <<== Stack overflow #8

正如你所看到的，这条链最终会解开，但它只上下了三层。对于数千个级别，这个数字会高得多：在溢出的过程中，每个f或g级别的错误数会增加两倍，因此对于n帧，错误数为2ⁿ。有了成千上万的n，你可以认为你的程序是无限的。