什么是StackOverflowError?

什么是StackOverflowError，是什么原因导致的，我应该如何处理它们?

当前回答

这是一个典型的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)

下面是OpenJDK 7中StackOverflowError的源代码。

2018-04-02 12:36:13

其他回答

堆栈溢出最常见的原因是过于深入或无限递归。如果这是你的问题，这个关于Java递归的教程可以帮助你理解这个问题。

2008-10-18 08:43:31

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

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

产生StackOverflowError的示例如下:

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

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

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

2012-07-17 21:23:44

这个问题的很多答案都是好的。但是，我想采取稍微不同的方法，并对内存的工作原理和(简化的)可视化更好地理解StackOverflow错误给出一些更深入的见解。这种理解不仅适用于Java，而且适用于所有进程。

在现代系统中，所有新进程都有自己的虚拟地址空间(VAS)。从本质上讲，VAS是操作系统在物理内存之上提供的抽象层，目的是确保进程之间不相互干扰内存。内核的任务是将虚拟地址映射到实际的物理地址。

VAS可以分为几个部分:

为了让CPU知道它应该做什么，机器指令必须加载到内存中。这通常被称为代码或文本段，具有静态大小。

在此之上，可以找到数据段和堆。数据段大小固定，包含全局变量或静态变量。当程序遇到特殊情况时，它可能需要额外分配数据，这就是堆发挥作用的地方，因此它能够动态地增长大小。

堆栈位于虚拟地址空间的另一侧，并使用后进先出(LIFO)数据结构跟踪所有函数调用。与堆类似，程序在运行时可能需要额外的空间来跟踪正在调用的新函数调用。由于堆栈位于VAS的另一侧，它正向相反的方向增长，即朝着堆的方向增长。

博士TL;

这就是StackOverflow错误发挥作用的地方。

由于堆栈向下增长(朝向堆)，可能会发生在某个时间点它不能继续增长，因为它会与堆地址空间重叠。一旦发生这种情况，就会发生StackOverflow错误。

发生这种情况最常见的原因是由于程序中的一个错误导致递归调用不能正确终止。

请注意，在某些系统上，VAS的行为可能略有不同，甚至可以分为更多的部分，但是，这种一般理解适用于所有UNIX系统。

2022-12-14 23:51:18

这里有一个例子

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-11 23:02:33