什么是 a StackOverflowError，是什么原因造成的，我应该如何处理它们？
Ziggy
问问题
748085 次
15 回答
446
参数和局部变量在堆栈上分配（对于引用类型，对象位于堆上，堆栈中的变量引用堆上的对象）。堆栈通常位于地址空间的上端，当它用完时，它会朝向地址空间的底部（即朝向零）。
您的进程也有一个heap，它位于进程的底部。当你分配内存时，这个堆会增长到地址空间的上端。如您所见，堆有可能与堆栈“碰撞”（有点像构造板块！！！）。
堆栈溢出的常见原因是错误的递归调用。通常，这是在您的递归函数没有正确的终止条件时引起的，因此它最终会永远调用自己。或者当终止条件很好时，它可能是由于在满足它之前需要太多递归调用造成的。
但是，通过 GUI 编程，可以生成间接递归。例如，您的应用程序可能正在处理绘画消息，并且在处理它们时，它可能会调用一个函数，该函数会导致系统发送另一条绘画消息。在这里，您没有明确称呼自己，但 OS/VM 已经为您完成了。
要处理它们，您需要检查您的代码。如果你有调用自己的函数，那么检查你是否有一个终止条件。如果有，请检查在调用函数时是否至少修改了一个参数，否则递归调用的函数将没有可见的变化，并且终止条件是无用的。另请注意，在达到有效终止条件之前，您的堆栈空间可能会耗尽内存，因此请确保您的方法可以处理需要更多递归调用的输入值。
如果您没有明显的递归函数，请检查您是否正在调用任何间接导致您的函数被调用的库函数（如上面的隐式案例）。
于 2008-10-18T08:34:31.467 回答
132
为了描述这一点，首先让我们了解局部变量和对象是如何存储的。
局部变量存储在堆栈中：
如果您查看图像，您应该能够理解事情是如何工作的。
当 Java 应用程序调用函数调用时，会在调用堆栈上分配一个堆栈帧。堆栈帧包含被调用方法的参数、其本地参数和方法的返回地址。返回地址表示被调用的方法返回后程序继续执行的执行点。如果没有空间用于新的堆栈帧，StackOverflowError则由 Java 虚拟机 (JVM) 抛出。
可能耗尽 Java 应用程序堆栈的最常见情况是递归。在递归中，方法在执行期间调用自身。递归被认为是一种强大的通用编程技术，但必须谨慎使用，以避免StackOverflowError.
抛出 a 的示例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使用指定线程堆栈大小等于 1 MB的标志的示例执行如下所示：
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
最简单的解决方案是仔细检查堆栈跟踪并检测行号的重复模式。这些行号表示被递归调用的代码。一旦你检测到这些行，你必须仔细检查你的代码并理解为什么递归永远不会终止。
如果您已验证正确实现了递归，则可以增加堆栈的大小，以允许更多的调用。根据安装的 Java 虚拟机 (JVM)，默认线程堆栈大小可能等于512 KB 或 1 MB。
-Xss您可以使用该标志增加线程堆栈大小。该标志可以通过项目的配置或命令行指定。参数的格式-Xss是：-Xss<size>[g|G|m|M|k|K]
于 2015-03-26T13:06:54.747 回答
69
如果你有这样的功能：
int foo()
{
// more stuff
foo();
}
然后 foo() 会不断地调用自己，越来越深，当用来跟踪你所在的函数的空间被填满时，你就会得到堆栈溢出错误。
于 2008-10-18T08:31:36.497 回答
25
堆栈溢出的确切含义是：堆栈溢出。通常程序中有一个堆栈，其中包含局部范围的变量和在例程执行结束时返回的地址。该堆栈往往是内存中某处的固定内存范围，因此它可以包含多少值是有限的。
如果堆栈为空，则无法弹出，否则会出现堆栈下溢错误。
如果堆栈已满，则无法推送，否则会出现堆栈溢出错误。
所以堆栈溢出出现在你分配太多到堆栈中的地方。例如，在提到的递归中。
一些实现优化了某些形式的递归。特别是尾递归。尾递归例程是例程的形式，其中递归调用作为例程所做的最后一件事出现。这样的例行调用被简单地简化为跳转。
一些实现甚至实现了自己的递归堆栈，因此它们允许递归继续，直到系统内存不足。
如果可以的话，你可以尝试的最简单的事情就是增加你的筹码量。如果你不能这样做，那么第二好的事情是查看是否有明显导致堆栈溢出的东西。通过在调用例程之前和之后打印一些东西来尝试它。这可以帮助您找出失败的例程。
于 2008-10-18T10:06:02.937 回答
11
堆栈溢出通常是由于函数调用嵌套太深（在使用递归时尤其容易，即调用自身的函数）或在堆栈上分配大量内存而使用堆更合适。
于 2008-10-18T08:19:15.680 回答
7
就像你说的，你需要展示一些代码。:-)
当您的函数调用嵌套太深时，通常会发生堆栈溢出错误。有关如何发生这种情况的一些示例，请参阅Stack Overflow Code Golf线程（尽管在该问题的情况下，答案故意导致堆栈溢出）。
于 2008-10-18T08:17:19.957 回答
6
StackOverflowError对堆栈和OutOfMemoryError堆一样。
无限递归调用会导致堆栈空间被用完。
以下示例产生StackOverflowError：
class StackOverflowDemo
{
public static void unboundedRecursiveCall() {
unboundedRecursiveCall();
}
public static void main(String[] args)
{
unboundedRecursiveCall();
}
}
StackOverflowError如果递归调用有界以防止不完整的内存调用（以字节为单位）的总和超过堆栈大小（以字节为单位），则可以避免。
于 2012-07-17T21:23:44.393 回答
5
堆栈溢出的最常见原因是过深或无限递归。如果这是您的问题，本关于 Java 递归的教程可以帮助您理解问题。
于 2008-10-18T08:43:31.357 回答
5
AStackOverflowError是 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)
在上述情况下，可以通过进行程序更改来避免。但是如果程序逻辑是正确的并且它仍然发生，那么你的堆栈大小需要增加。
于 2017-03-30T11:08:57.267 回答
3
这是用于反转单链表的递归算法的示例。在笔记本电脑上（规格为 4 GB 内存，Intel Core i5 2.3 GHz CPU 64 位和 Windows 7），此函数将遇到大小接近 10,000 的链表的 StackOverflow 错误。
我的观点是我们应该明智地使用递归，始终考虑系统的规模。
通常递归可以转换为迭代程序，它可以更好地扩展。（页面底部给出了相同算法的一个迭代版本。它在 9 毫秒内反转了一个大小为 100 万的单链表。）
private static LinkedListNode doReverseRecursively(LinkedListNode x, LinkedListNode first){
LinkedListNode second = first.next;
first.next = x;
if(second != null){
return doReverseRecursively(first, second);
}else{
return first;
}
}
public static LinkedListNode reverseRecursively(LinkedListNode head){
return doReverseRecursively(null, head);
}
相同算法的迭代版本：
public static LinkedListNode reverseIteratively(LinkedListNode head){
return doReverseIteratively(null, head);
}
private static LinkedListNode doReverseIteratively(LinkedListNode x, LinkedListNode first) {
while (first != null) {
LinkedListNode second = first.next;
first.next = x;
x = first;
if (second == null) {
break;
} else {
first = second;
}
}
return first;
}
public static LinkedListNode reverseIteratively(LinkedListNode head){
return doReverseIteratively(null, head);
}
于 2013-01-16T19:49:52.140 回答
3
堆栈具有取决于操作系统的空间限制。正常大小为 8 MB（在Ubuntu (Linux) 中，您可以检查该限制，$ ulimit -u并且可以类似地在其他操作系统中检查）。任何程序都在运行时使用堆栈，但要完全知道何时使用它，您需要检查汇编语言。例如，在 x86_64 中，堆栈用于：
- 进行过程调用时保存返回地址
- 保存局部变量
- 保存特殊寄存器以便以后恢复它们
- 将参数传递给过程调用（超过 6 个）
- 其他：随机未使用的堆栈基数、金丝雀值、填充等。
如果您不了解 x86_64（正常情况），您只需要知道您使用的特定高级编程语言何时编译到这些操作。例如在 C 中：
- (1) → 一个函数调用
- (2)→函数调用中的局部变量（包括main）
- (3)→函数调用中的局部变量（不是main）
- (4) → 函数调用
- (5) → 通常是函数调用，一般与堆栈溢出无关。
因此，在 C 中，只有局部变量和函数调用会使用堆栈。造成堆栈溢出的两种（独特的？）方法是：
- 在 main 或在 (
int array[10000][10000];)中调用的任何函数中声明过大的局部变量 - 非常深或无限的递归（同时调用太多函数）。
为了避免StackOverflowError你可以：
检查局部变量是否太大（1 MB 的顺序）→ 使用堆（malloc/calloc 调用）或全局变量。
检查无限递归→你知道该怎么做......纠正它！
检查正常的太深递归→最简单的方法是将实现更改为迭代。
另请注意，全局变量、包含库等...不使用堆栈。
仅当上述方法不起作用时，将堆栈大小更改为特定操作系统上的最大值。以 Ubuntu 为例：ulimit -s 32768(32 MB)。（这从来都不是我的任何堆栈溢出错误的解决方案，但我也没有太多经验。）
我省略了 C 中的特殊和/或非标准用例（例如 ofalloc()和类似的用法），因为如果您使用它们，您应该已经确切地知道自己在做什么。
于 2020-07-09T11:15:40.643 回答
2
在紧要关头，以下情况会带来堆栈溢出错误。
public class Example3 {
public static void main(String[] args) {
main(new String[1]);
}
}
于 2020-02-26T14:40:29.153 回答
1
一个由于递归调用错误而导致 java.lang.StackOverflowError 的简单 Java 示例：
class Human {
Human(){
new Animal();
}
}
class Animal extends Human {
Animal(){
super();
}
}
public class Test01 {
public static void main(String[] args) {
new Animal();
}
}
于 2021-01-31T08:53:10.867 回答
0
这是一个例子
public static void main(String[] args) {
System.out.println(add5(1));
}
public static int add5(int a) {
return add5(a) + 5;
}
StackOverflowError 基本上是当您尝试做某事时，它很可能会调用自身，并持续到无穷大（或直到它给出 StackOverflowError）。
add5(a)将调用自身，然后再次调用自身，依此类推。
于 2016-02-11T23:02:33.307 回答
0
这是一个典型的例子java.lang.StackOverflowError......该方法递归地调用自己，没有退出doubleValue()，floatValue()等。
文件Rational.java
public class Rational extends Number implements Comparable<Rational> {
private int num;
private int denom;
public Rational(int num, int denom) {
this.num = num;
this.denom = denom;
}
public int compareTo(Rational r) {
if ((num / denom) - (r.num / r.denom) > 0) {
return +1;
} else if ((num / denom) - (r.num / r.denom) < 0) {
return -1;
}
return 0;
}
public Rational add(Rational r) {
return new Rational(num + r.num, denom + r.denom);
}
public Rational sub(Rational r) {
return new Rational(num - r.num, denom - r.denom);
}
public Rational mul(Rational r) {
return new Rational(num * r.num, denom * r.denom);
}
public Rational div(Rational r) {
return new Rational(num * r.denom, denom * r.num);
}
public int gcd(Rational r) {
int i = 1;
while (i != 0) {
i = denom % r.denom;
denom = r.denom;
r.denom = i;
}
return denom;
}
public String toString() {
String a = num + "/" + denom;
return a;
}
public double doubleValue() {
return (double) doubleValue();
}
public float floatValue() {
return (float) floatValue();
}
public int intValue() {
return (int) intValue();
}
public long longValue() {
return (long) longValue();
}
}
文件Main.java
public class Main {
public static void main(String[] args) {
Rational a = new Rational(2, 4);
Rational b = new Rational(2, 6);
System.out.println(a + " + " + b + " = " + a.add(b));
System.out.println(a + " - " + b + " = " + a.sub(b));
System.out.println(a + " * " + b + " = " + a.mul(b));
System.out.println(a + " / " + b + " = " + a.div(b));
Rational[] arr = {new Rational(7, 1), new Rational(6, 1),
new Rational(5, 1), new Rational(4, 1),
new Rational(3, 1), new Rational(2, 1),
new Rational(1, 1), new Rational(1, 2),
new Rational(1, 3), new Rational(1, 4),
new Rational(1, 5), new Rational(1, 6),
new Rational(1, 7), new Rational(1, 8),
new Rational(1, 9), new Rational(0, 1)};
selectSort(arr);
for (int i = 0; i < arr.length - 1; ++i) {
if (arr[i].compareTo(arr[i + 1]) > 0) {
System.exit(1);
}
}
Number n = new Rational(3, 2);
System.out.println(n.doubleValue());
System.out.println(n.floatValue());
System.out.println(n.intValue());
System.out.println(n.longValue());
}
public static <T extends Comparable<? super T>> void selectSort(T[] array) {
T temp;
int mini;
for (int i = 0; i < array.length - 1; ++i) {
mini = i;
for (int j = i + 1; j < array.length; ++j) {
if (array[j].compareTo(array[mini]) < 0) {
mini = j;
}
}
if (i != mini) {
temp = array[i];
array[i] = array[mini];
array[mini] = temp;
}
}
}
}
结果
2/4 + 2/6 = 4/10
Exception in thread "main" java.lang.StackOverflowError
2/4 - 2/6 = 0/-2
at com.xetrasu.Rational.doubleValue(Rational.java:64)
2/4 * 2/6 = 4/24
at com.xetrasu.Rational.doubleValue(Rational.java:64)
2/4 / 2/6 = 12/8
at com.xetrasu.Rational.doubleValue(Rational.java:64)
at com.xetrasu.Rational.doubleValue(Rational.java:64)
at com.xetrasu.Rational.doubleValue(Rational.java:64)
at com.xetrasu.Rational.doubleValue(Rational.java:64)
at com.xetrasu.Rational.doubleValue(Rational.java:64)
于 2018-04-02T12:36:13.817 回答