Java中有两个主要的存储位置。第一个是Heap，用于动态分配对象。新的。

此外，每个运行的线程都有自己的堆栈，并获得分配给该堆栈的一定数量的内存。

当您调用一个方法时，数据将被推入堆栈以记录方法调用、传入的参数和分配的任何局部变量。具有五个局部变量和三个参数的方法将比没有局部变量的void doStuff()方法使用更多的堆栈空间。

堆栈的主要优点是没有内存碎片，一个方法调用的所有内容都分配在堆栈顶部，并且从方法返回很容易。要从一个方法返回，只需将堆栈展开到前一个方法，为返回值设置所需的任何值，就完成了。

Because the stack is a fixed size per thread, (note that the Java Spec does not require a fixed size, but most JVM implementations at the time of writing use a fixed size) and because space on the stack is needed whenever you make a method call hopefully it should now be clear why it can run out and what can cause it to run out. There isn't a fixed number of method calls, there isn't anything specific about recursion, you get the exception which you try to call a method and there isn't enough memory.

当然，堆栈的大小设置得足够高，以至于在常规代码中不太可能发生这种情况。在递归代码中，递归很容易深入到很深的地方，这时你就会遇到这个错误。

但这引发了两个问题: 除了通过递归，没有其他方法可以导致堆栈溢出吗? StackOverflowError发生在JVM溢出堆栈之前还是之后?

当我们分配的大小大于栈的限制时(例如。int x[10000000];)。 第二个答案是

Each thread has its own stack that holds a frame for each method executing on that thread. So the currently executing method is at the top of the stack. A new frame is created and added (pushed) to the top of stack for every method invocation. The frame is removed (popped) when the method returns normally or if an uncaught exception is thrown during the method invocation. The stack is not directly manipulated, except to push and pop frame objects, and therefore the frame objects may be allocated in the Heap and the memory does not need to be contiguous.

因此，通过考虑线程中的堆栈，我们可以得出结论。

堆栈的大小可以是动态的，也可以是固定的。如果线程需要的堆栈大于允许的堆栈，则抛出StackOverflowError。如果一个线程需要一个新的帧，并且没有足够的内存分配它，则抛出OutOfMemoryError。

你可以在这里获得JVM的描述

除了通过递归，没有其他方法可以导致堆栈溢出吗?

当然。只需要继续调用方法，而不返回。不过，您将需要很多方法，除非您允许递归。实际上，这并没有什么区别:一个堆栈框架就是一个堆栈框架，不管它是不是递归方法之一都是一样的。

第二个问题的答案是:当JVM试图为下一个调用分配堆栈帧时，发现不可能分配堆栈帧，就会检测到stackoverflow。所以，没有东西会被覆盖。

StackOverflow发生在函数调用时，堆栈已满。

就像一个ArrayOutOfBoundException。它不会腐蚀任何东西，事实上很有可能抓住它并从中恢复。

它通常是由于不受控制的递归导致的，但也可能是由于调用了非常深的函数堆栈而导致的。

就没有其他方式发生堆栈溢出了吗 通过递归?

没有递归的StackOverflowError(挑战失败，见评论):

public class Test
{
    final static int CALLS = 710;

    public static void main(String[] args)
    {
        final Functor[] functors = new Functor[CALLS];
        for (int i = 0; i < CALLS; i++)
        {
            final int finalInt = i;
            functors[i] = new Functor()
            {
                @Override
                public void fun()
                {
                    System.out.print(finalInt + " ");
                    if (finalInt != CALLS - 1)
                    {
                        functors[finalInt + 1].fun();
                    }
                }
            };
        }
        // Let's get ready to ruuuuuuumble!
        functors[0].fun(); // Sorry, couldn't resist to not comment in such moment. 
    }

    interface Functor
    {
        void fun();
    }
}

使用标准javac Test.java编译，并使用java -Xss104k Test 2>输出运行。在那之后，更多的信息会告诉你:

Exception in thread "main" java.lang.StackOverflowError

第二次尝试。

现在这个想法更简单了。Java中的原语可以存储在堆栈上。我们声明很多双精度数，比如双精度a1 a2 a3....这个脚本可以为我们编写，编译和运行代码:

#!/bin/sh

VARIABLES=4000
NAME=Test
FILE=$NAME.java
SOURCE="public class $NAME{public static void main(String[] args){double "
for i in $(seq 1 $VARIABLES);
do
    SOURCE=$SOURCE"a$i,"
done
SOURCE=$SOURCE"b=0;System.out.println(b);}}"
echo $SOURCE > $FILE
javac $FILE
java -Xss104k $NAME

和…我得到了一些意想不到的东西:

#
# A fatal error has been detected by the Java Runtime Environment:
#
#  SIGSEGV (0xb) at pc=0x00007f4822f9d501, pid=4988, tid=139947823249152
#
# JRE version: 6.0_27-b27
# Java VM: OpenJDK 64-Bit Server VM (20.0-b12 mixed mode linux-amd64 compressed oops)
# Derivative: IcedTea6 1.12.6
# Distribution: Ubuntu 10.04.1 LTS, package 6b27-1.12.6-1ubuntu0.10.04.2
# Problematic frame:
# V  [libjvm.so+0x4ce501]  JavaThread::last_frame()+0xa1
#
# An error report file with more information is saved as:
# /home/adam/Desktop/test/hs_err_pid4988.log
#
# If you would like to submit a bug report, please include
# instructions how to reproduce the bug and visit:
#   https://bugs.launchpad.net/ubuntu/+source/openjdk-6/
#
Aborted

这是100%的重复。这和你第二个问题有关。

是否在JVM实际溢出之前发生StackOverflowError 叠完还是之后?

因此，在OpenJDK 20.0-b12的情况下，我们可以看到JVM首先爆发了。但这似乎是一个bug，也许有人可以在评论中确认，因为我不确定。我应该报告吗?也许它已经在一些更新的版本中修复了……根据JVM规范链接(由JB Nizet在评论中给出)，JVM应该抛出StackOverflowError，而不是die:

如果线程中的计算需要一个更大的Java虚拟机 Java虚拟机抛出一个 StackOverflowError。

第三次尝试。

public class Test {
    Test test = new Test();

    public static void main(String[] args) {
        new Test();
    }
}

我们想要创建新的Test对象。因此，它的(隐式)构造函数将被调用。但是，在此之前，Test的所有成员都被初始化了。因此，首先执行Test Test = new Test()…

我们想要创建一个新的Test对象…

更新:运气不好，这是递归，我在这里问了一个问题。

在c#中，可以通过错误地定义对象属性来实现堆栈溢出。 例如:

private double hours;

public double Hours
        {
            get { return Hours; }
            set { Hours = value; }
        }

如你所见，它会一直返回带有大写H的Hours, H本身也会返回Hours，等等。

堆栈溢出也经常发生，因为内存不足，或者当使用托管语言时，因为您的语言管理器(CLR, JRE)将检测到您的代码陷入无限循环。