StackOverFlowError最常见的原因是过度深度递归或无限递归。

例如:

public int yourMethod(){
       yourMethod();//infinite recursion
}

在Java中:

内存中有两个区域:堆和堆栈。堆栈内存用于存储局部变量和函数调用，而堆内存用于存储Java中的对象。

如果堆栈中没有剩余内存用于存储函数调用或本地变量，JVM将抛出java.lang.StackOverFlowError

而如果没有更多的堆空间来创建对象，JVM将抛出java.lang.OutOfMemoryError

但这引发了两个问题: 除了通过递归，没有其他方法可以导致堆栈溢出吗? 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的描述

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

没有递归的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对象…

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

StackOverFlowError最常见的原因是过度深度递归或无限递归。

例如:

public int yourMethod(){
       yourMethod();//infinite recursion
}

在Java中:

内存中有两个区域:堆和堆栈。堆栈内存用于存储局部变量和函数调用，而堆内存用于存储Java中的对象。

如果堆栈中没有剩余内存用于存储函数调用或本地变量，JVM将抛出java.lang.StackOverFlowError

而如果没有更多的堆空间来创建对象，JVM将抛出java.lang.OutOfMemoryError

似乎您认为stackoverflow错误类似于本机程序中的缓冲区溢出异常，此时存在将未分配给缓冲区的内容写入内存的风险，从而破坏一些其他内存位置。根本不是这样的。

JVM为每个线程的每个堆栈分配了一个给定的内存，如果试图调用一个方法恰好填满了这个内存，JVM就会抛出一个错误。就像你想写一个长度为N的数组的下标N一样，不会发生内存损坏。堆栈不能写入堆。

StackOverflowError之于堆栈，就像OutOfMemoryError之于堆:它只是表明没有更多可用内存。

来自虚拟机错误的描述(§6.3)

StackOverflowError: Java虚拟机实现已经耗尽了线程的堆栈空间，通常是因为由于执行程序中的错误，线程正在执行无限数量的递归调用。

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.

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