要描述这一点，首先让我们了解局部变量和对象是如何存储的。

局部变量存储在堆栈上:

如果你看了图片，你应该能够理解事情是如何工作的。

当Java应用程序调用函数时，将在调用堆栈上分配堆栈帧。堆栈帧包含被调用方法的参数、局部参数和方法的返回地址。返回地址表示执行点，在调用的方法返回后，程序将从该执行点继续执行。如果没有空间用于新的堆栈帧，那么Java虚拟机(JVM)将抛出StackOverflowError。

可能耗尽Java应用程序堆栈的最常见情况是递归。在递归中，方法在执行过程中调用自身。递归被认为是一种强大的通用编程技术，但必须谨慎使用，以避免StackOverflowError。

抛出StackOverflowError的示例如下所示:

StackOverflowErrorExample.java:

public class StackOverflowErrorExample {

    public static void recursivePrint(int num) {
        System.out.println("Number: " + num);
        if (num == 0)
            return;
        else
            recursivePrint(++num);
        }

    public static void main(String[] args) {
        StackOverflowErrorExample.recursivePrint(1);
    }
}

在本例中，我们定义了一个递归方法recursivePrint，它打印一个整数，然后调用自身，并将下一个连续整数作为参数。递归结束，直到我们传入0作为参数。然而，在我们的例子中，我们传递了参数1和它不断增加的追随者，因此，递归永远不会结束。

一个示例执行，使用-Xss1M标志，指定线程堆栈的大小为1mb，如下所示:

Number: 1
Number: 2
Number: 3
...
Number: 6262
Number: 6263
Number: 6264
Number: 6265
Number: 6266
Exception in thread "main" java.lang.StackOverflowError
        at java.io.PrintStream.write(PrintStream.java:480)
        at sun.nio.cs.StreamEncoder.writeBytes(StreamEncoder.java:221)
        at sun.nio.cs.StreamEncoder.implFlushBuffer(StreamEncoder.java:291)
        at sun.nio.cs.StreamEncoder.flushBuffer(StreamEncoder.java:104)
        at java.io.OutputStreamWriter.flushBuffer(OutputStreamWriter.java:185)
        at java.io.PrintStream.write(PrintStream.java:527)
        at java.io.PrintStream.print(PrintStream.java:669)
        at java.io.PrintStream.println(PrintStream.java:806)
        at StackOverflowErrorExample.recursivePrint(StackOverflowErrorExample.java:4)
        at StackOverflowErrorExample.recursivePrint(StackOverflowErrorExample.java:9)
        at StackOverflowErrorExample.recursivePrint(StackOverflowErrorExample.java:9)
        at StackOverflowErrorExample.recursivePrint(StackOverflowErrorExample.java:9)
        ...

根据JVM的初始配置，结果可能不同，但最终将抛出StackOverflowError。这个例子很好地说明了如果不小心实现递归，它是如何导致问题的。

如何处理StackOverflowError

The simplest solution is to carefully inspect the stack trace and detect the repeating pattern of line numbers. These line numbers indicate the code being recursively called. Once you detect these lines, you must carefully inspect your code and understand why the recursion never terminates. If you have verified that the recursion is implemented correctly, you can increase the stack’s size, in order to allow a larger number of invocations. Depending on the Java Virtual Machine (JVM) installed, the default thread stack size may equal to either 512 KB, or 1 MB. You can increase the thread stack size using the -Xss flag. This flag can be specified either via the project’s configuration, or via the command line. The format of the -Xss argument is: -Xss<size>[g|G|m|M|k|K]

StackOverflowError之于堆栈，就像OutOfMemoryError之于堆。

无界递归调用会导致堆栈空间被用完。

产生StackOverflowError的示例如下:

class  StackOverflowDemo
{
    public static void unboundedRecursiveCall() {
     unboundedRecursiveCall();
    }

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

如果对递归调用进行了限制，以防止内存中不完整调用的总和(以字节为单位)超过堆栈大小(以字节为单位)，则可以避免StackOverflowError。

堆栈有一个空间限制，这取决于操作系统。正常的大小是8mb(在Ubuntu (Linux)中，你可以用$ ulimit -u检查这个限制，在其他操作系统中也可以类似地检查)。任何程序都在运行时使用堆栈，但要完全了解何时使用堆栈，您需要检查汇编语言。例如，在x86_64中，堆栈用于:

在进行过程调用时保存返回地址 保存本地变量 保存特殊寄存器以便稍后恢复它们 向过程调用传递参数(大于6) 其他:随机未使用的堆栈基础，金丝雀值，填充，…等。

如果您不知道x86_64(一般情况下)，您只需要知道您所使用的特定高级编程语言何时编译这些操作。例如在C语言中:

→函数调用 (2)→函数调用中的局部变量(包括main) (3)→函数调用中的局部变量(不是main) →函数调用 (5)→通常是一个函数调用，通常与堆栈溢出无关。

因此，在C语言中，只有局部变量和函数调用使用堆栈。造成堆栈溢出的两种(唯一的?)方法是:

在main或任何函数中声明过大的局部变量(int array[10000][10000];) 深度递归或无限递归(同时调用太多函数)。

要避免StackOverflowError，您可以:

检查局部变量是否太大(1mb数量级)→使用堆(malloc/calloc调用)或全局变量。 检查无限递归→你知道该怎么做…正确的! 检查常规的深度递归→最简单的方法是将实现更改为迭代。

还要注意全局变量、包含库等等……不要使用堆栈。

只有当上述方法不起作用时，才可以在特定的操作系统上将堆栈大小更改为最大值。例如Ubuntu: ulimit -s 32768 (32 MB)。(这从来都不是我的任何堆栈溢出错误的解决方案，但我也没有太多经验。)

我省略了C语言中的特殊和/或非标准情况(例如alloc()和类似的用法)，因为如果你正在使用它们，你应该已经确切地知道你在做什么。

StackOverflowError是Java中的运行时错误。

当超过JVM分配的调用堆栈内存量时抛出该异常。

抛出StackOverflowError的一种常见情况是由于过度深度递归或无限递归而导致调用堆栈超出。

例子:

public class Factorial {
    public static int factorial(int n){
        if(n == 1){
            return 1;
        }
        else{
            return n * factorial(n-1);
        }
    }

    public static void main(String[] args){
         System.out.println("Main method started");
        int result = Factorial.factorial(-1);
        System.out.println("Factorial ==>"+result);
        System.out.println("Main method ended");
    }
}

堆栈跟踪:

Main method started
Exception in thread "main" java.lang.StackOverflowError
at com.program.stackoverflow.Factorial.factorial(Factorial.java:9)
at com.program.stackoverflow.Factorial.factorial(Factorial.java:9)
at com.program.stackoverflow.Factorial.factorial(Factorial.java:9)

在上述情况下，可以通过进行编程更改来避免这种情况。 但如果程序逻辑是正确的，它仍然发生，那么你的堆栈大小需要增加。

如您所说，您需要展示一些代码。: -)

堆栈溢出错误通常发生在函数调用nest太深的时候。请参阅Stack Overflow Code Golf线程，以了解如何发生这种情况(尽管在这个问题的情况下，答案会故意导致堆栈溢出)。

参数和局部变量分配在堆栈上(对于引用类型，对象位于堆上，堆栈中的变量引用堆上的对象)。堆栈通常位于地址空间的上端，当它被用完时，它会朝向地址空间的底部(即朝向零)。

你的进程也有一个堆，它位于你的进程的底部。当您分配内存时，这个堆可以向地址空间的顶端增长。正如您所看到的，堆有可能与堆栈“碰撞”(有点像构造板块!!)。

导致堆栈溢出的常见原因是错误的递归调用。通常，这是当递归函数没有正确的终止条件时引起的，因此它最终永远调用自己。或者当终止条件良好时，可能是由于在实现终止条件之前需要太多的递归调用而导致的。

但是，使用GUI编程，可以生成间接递归。例如，你的应用程序可能正在处理paint消息，在处理它们的同时，它可能会调用一个函数，导致系统发送另一个paint消息。这里您没有显式地调用自己，但是OS/VM已经为您完成了。

To deal with them, you'll need to examine your code. If you've got functions that call themselves then check that you've got a terminating condition. If you have, then check that when calling the function you have at least modified one of the arguments, otherwise there'll be no visible change for the recursively called function and the terminating condition is useless. Also mind that your stack space can run out of memory before reaching a valid terminating condition, thus make sure your method can handle input values requiring more recursive calls.

如果没有明显的递归函数，则检查是否调用了间接导致函数被调用的库函数(如上面的隐式情况)。