终于不抛出堆栈溢出异常

Question

据我所知，这段代码应该抛出 StackOverflowError，但事实并非如此。可能是什么原因？

public class SimpleFile {

    public static void main(String[] args) {
        System.out.println("main");

        try{
        SimpleFile.main(args);
            }

        catch(Exception e){
            System.out.println("Catch");
        }

        finally{
            SimpleFile.main(args);
        }
    }

}

Answer 1

Error 不是Exception。所以捕获任何异常都不会捕获 StackOverflowError。

因此，让我们从修复“明显错误”开始 - （此代码不可取，如本答案后面所述）：

    catch(Throwable e){
        System.out.println("Catch");
    }

如果您进行此更改，您会发现代码仍然无法打印。但它并没有因为一个非常不同的原因打印......

非常不鼓励捕获任何ERROR（包括StackOverflowError）。但是在这里，您不仅要捕获一个，而且要捕获一个，因为它发生在堆栈的顶部。即使使用您的代码（没有上述更改），finally 块也有效地捕获了错误。

StackOverflowError 发生在堆栈已满并且您尝试向其中添加更多内容时。因此，当您发现错误时，堆栈仍然是满的。您不能调用任何方法（甚至打印到控制台），因为堆栈已满。因此，在成功打印之前，catch 中会抛出第二个 StackOverflowError。

这样做的结果是：

1. 捕获错误
2. 尝试打印错误
3. 由于无法打印而导致另一个错误
4. 调用finally，因为 finally总是被调用。
5. 导致另一个错误，因为它无法调用main
6. 将错误级联回遇到相同错误的上一个调用。

这里的关键是最终它会开始打印一些东西。但是对print 的调用会占用大量堆栈空间，并且您的代码将不得不在很长一段时间中重复上述各点并出错，然后才能释放足够的堆栈空间来打印。根据 Holger 对 Oracle 的 Java 8 的评论，将 println 堆栈帧所需的 main 堆栈帧数接近 50。

250 = 1,125,899,906,842,624

这就是为什么你不应该发现错误。

只有少数借口可以让你打破这条规则，而且你已经亲身发现如果你真的打破它会出现什么问题。

Answer 2

其实你有 java.lang.Stackoverflow

您可以运行此示例代码：

public class SimpleFile {
    public static void main(String[] args) {
       System.out.println("main ");
       try{
          SimpleFile.main(args);
       }finally{
          try{
             SimpleFile.main(args);
          }catch(Error e2){
             System.out.println("finally");
             throw e2;
          }
       }
   }
}

PS

更多细节：你的程序打印了很多 main 消息，之后你第一次收到堆栈溢出错误并转到 finally 块。这意味着你减少了堆栈大小，现在你可以调用一些东西。但是你在 finally 块中调用自己并再次获得堆栈溢出。最让我惊讶的是输出不稳定：

 main 
 main main finally
 main 
 main main finallyfinallyfinally
 main 
 main 

Answer 3

首先，您有一个 catch 子句，它不会捕获 Errors：

catch(Exception e){
    System.out.println("Catch");
}

由于Errors 不是Exceptions，这不会捕获StackOverflowErrors 并且打印语句不会被执行。如果 Error 没有被捕获，它的堆栈跟踪将由线程的默认处理程序打印，如果它到达那个点。但是你还有另一个子句：

finally{
    SimpleFile.main(args);
}

finally 子句的代码将始终在 try 块完成时执行，无论是正常还是异常。由于您的 try 块包含无限递归，它永远不会正常完成。

在例外情况下，即当抛出StackOverflowError 时，finally 操作将再次进入无限递归，最终可能再次以StackOverflowError 失败，但由于它具有相同的@987654336 @block，它也会再次进入无限递归。

您的程序基本上是在说“执行一次无限递归，然后再执行一次无限递归”。请注意，您无法区分 "main" 的打印，该程序是在主无限递归中运行还是在 finally 块触发的程序中运行（除非在 @987654339 之间发生堆栈溢出时可能会丢失换行符@执行）。

因此，如果我们假设特定 JVM 的嵌套调用限制为 1000，那么您的程序将执行 2¹⁰⁰⁰ 调用 main 方法 (quantification)。由于您的 main 方法实际上什么都不做，优化器甚至可以忽略如此多的调用，但这种优化也意味着所需的堆栈大小消失了，因此，更多的递归调用成为可能。只有一个 JVM 实现对支持的递归调用数量进行有意限制，独立于实际需要的堆栈空间，才能强制该程序永远终止。

但请注意，在无限递归的情况下，根本无法保证获得StackOverflowError。从理论上讲，具有无限堆栈空间的 JVM 将是一个有效的实现。这意味着，实际上优化递归代码以在不需要额外堆栈空间的情况下运行的 JVM 也是有效的。

因此，对于像 Oracle 的 JVM 这样的典型实现，您的程序几乎不可能报告StackOverflowError。它们会发生，但会被您在 finally 块中的后续递归所掩盖，因此永远不会被报告。

Answer 4

我对您的代码进行了一些修改并进行了一些测试。我仍然无法弄清楚你的问题的答案。肯定是 finally 块导致代码的整个厌倦行为。

public class SimpleFile {

    static int i = 0;

    public static void main(String[] args) {
        int c = i++;
        System.out.println("main" + i);

        try {
            SimpleFile.main(args);
        }

        catch (Throwable e) {
            System.out.println("Catch" + e);
        }

        finally {
            if (i < 30945) {
                System.out.println("finally" + c);
                SimpleFile.main(args);
            }
        }
    }
}

输出是..我只显示最后几行：

main30941
main30942finally30940
main30943finally30927
main30944
main30945
main30946
main30947Catchjava.lang.StackOverflowError

我想证明，如果递归调用，即使是静态方法也会得到 StackOverflowError。而且由于您正在捕获永远不会捕获错误的异常。

如果 main 被递归调用，请参阅 Call Main Recursively 问题以了解 StackOverflowError

Answer 5

静态方法是永久性的，它不存储在堆栈中，而是存储在堆中。您编写的代码代码只是从堆中一遍又一遍地调用相同的代码，因此它不会抛出StackOverFlowError。此外，System.out.println("main"); 中的字符串存储在同一位置，这是永久性的。即使你一遍又一遍地调用代码，使用相同的字符串对象，它不会填满堆栈。

我从以下链接得到了这个解释：

http://www.oracle.com/technetwork/java/javase/memleaks-137499.html#gbyuu

3.1.2 详细消息：PermGen space 详细消息 PermGen space 表示永久代已满。永久的 代是堆中类和方法对象所在的区域 存储。如果一个应用程序加载了大量的类，那么 永久代的大小可能需要使用 -XX:MaxPermSize 选项。

interned java.lang.String 对象也存储在永久 一代。 java.lang.String 类维护一个字符串池。 调用 intern 方法时，该方法会检查池以查看 如果池中已经有一个相等的字符串。如果有，那么 实习生方法返回它；否则它将字符串添加到池中。在 更准确地说，java.lang.String.intern 方法用于 获取字符串的规范表示；结果是一个 引用相同的类实例，如果那样的话 字符串作为文字出现。如果一个应用程序实习了大量 字符串，永久代可能需要从 其默认设置。

当出现此类错误时，文本 String.intern 或 ClassLoader.defineClass 可能出现在堆栈跟踪顶部附近 打印出来的。

jmap -permgen 命令打印 永久代，包括有关内部化字符串的信息 实例。