什么是*Error？

程序员文章站 2022-07-14 18:26:18

...

什么是*Error ，是什么原因引起的，我该如何处理？

#1楼

*Error是堆栈，而OutOfMemoryError是堆栈。

无限制的递归调用会导致堆栈空间用尽。

以下示例产生*Error ：

class  *Demo
{
    public static void unboundedRecursiveCall() {
     unboundedRecursiveCall();
    }

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

如果绑定了递归调用以防止不完整的内存中调用（以字节为单位）的合计总数超过堆栈大小（以字节为单位），则可以避免*Error 。

#2楼

这是用于反转单个链表的递归算法的示例。在具有以下规格（4G内存，Intel Core i5 2.3GHz CPU，64位Windows 7）的笔记本电脑上，对于大小接近10,000的链表，此功能将遇到*错误。

我的观点是，我们应该明智地使用递归，并始终考虑系统的规模。通常，递归可以转换为迭代程序，可扩展性更好。（同一算法的一个迭代版本在页面底部给出，它在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);
}

#3楼

经常使用术语“堆栈溢出（溢出）”，但用词不当；攻击不会使堆栈溢出，而是会在堆栈上进行缓冲。

-来自Dieter Gollmann教授的演讲幻灯片

#4楼

就像您说的那样，您需要显示一些代码。 :-)

当函数调用嵌套太深时，通常会发生堆栈溢出错误。有关如何发生这种情况的一些示例，请参见“ 堆栈溢出代码”高尔夫球线程（尽管在该问题的情况下，答案有意导致堆栈溢出）。

#5楼

堆栈溢出通常是由嵌套函数调用太深（特别是在使用递归，即调用自身的函数时）引起的，或者在堆栈上分配大量内存（使用堆更合适）时调用的。

#6楼

如果您具有以下功能：

int foo()
{
    // more stuff
    foo();
}

然后foo（）会不断调用自身，并且越来越深，并且当用于跟踪您所使用的函数的空间被填满时，您会得到堆栈溢出错误。

#7楼

参数和局部变量在堆栈上分配（使用引用类型，对象位于堆上，而堆栈中的变量引用该对象在堆上）。堆栈一般住在你的地址空间的上端并且当它被用完时它朝向头的地址空间的底部（即，朝向零）。

您的流程还具有一个堆，该堆位于流程的最底端 。分配内存时，该堆可能会朝地址空间的高端增长。如您所见，堆有可能与堆“碰撞” （有点像构造板块！！！）。

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

但是，使用GUI编程，可以生成间接递归 。例如，您的应用程序可能正在处理绘画消息，并且在处理它们时，它可能会调用使系统发送另一个绘画消息的函数。在这里，您没有明确地给自己打电话，但是OS / VM已经为您完成了。

要处理它们，您需要检查您的代码。如果您有调用自己的函数，请检查是否有终止条件。如果有，请检查在调用该函数时是否至少已修改其中一个参数，否则递归调用的函数将没有可见的更改，并且终止条件无用。还请注意，在达到有效的终止条件之前，堆栈空间可能会用完内存，因此请确保您的方法可以处理需要更多递归调用的输入值。

如果您没有明显的递归函数，请检查是否正在调用任何间接导致您的函数被调用的库函数（如上述隐式情况）。

#8楼

堆栈溢出的最常见原因是过深或无限递归 。如果这是您的问题，那么有关Java递归的本教程可以帮助您理解该问题。

#9楼

堆栈溢出恰好意味着：堆栈溢出。通常，程序中只有一个堆栈，其中包含局部作用域变量，并说明例程执行结束时返回的位置。该堆栈往往是内存中某个位置的固定内存范围，因此限制了它可以包含值的数量。

如果堆栈为空，则无法弹出，如果弹出，则会出现堆栈下溢错误。

如果堆栈已满，则无法推动，如果这样做，则会出现堆栈溢出错误。

因此，在您向堆栈分配过多空间的地方会出现堆栈溢出。例如，在提到的递归中。

一些实现优化了某些形式的递归。尾递归尤其如此。尾递归例程是例程的形式，其中递归调用最终显示为例程的工作。这样的例行调用简单地简化为跳转。

某些实现甚至实现了自己的递归堆栈，因此它们允许递归继续进行，直到系统内存不足。

您可以尝试的最简单方法是增加堆栈大小。如果您不能执行此操作，那么第二件事就是查看是否有明显导致堆栈溢出的内容。通过在调用例程之前和之后打印一些内容来进行尝试。这可以帮助您找出失败的例程。

#10楼

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

局部变量存储在堆栈中 ：什么是*Error？

如果您查看图像，您应该能够理解事物的工作方式。

当Java应用程序调用函数调用时，将在调用堆栈上分配一个堆栈框架。堆栈框架包含调用的方法的参数，其本地参数以及方法的返回地址。返回地址表示执行点，从该执行点开始，在调用的方法返回后，程序将继续执行。如果没有空间用于新的堆栈框架，则Java虚拟机（JVM）会引发*Error 。

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

抛出*Error的示例如下所示：

*ErrorExample.java：

public class *ErrorExample {

    public static void recursivePrint(int num) {
        System.out.println("Number: " + num);

        if(num == 0)
            return;
        else
            recursivePrint(++num);
    }

    public static void main(String[] args) {
        *ErrorExample.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.*Error
        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 *ErrorExample.recursivePrint(*ErrorExample.java:4)
        at *ErrorExample.recursivePrint(*ErrorExample.java:9)
        at *ErrorExample.recursivePrint(*ErrorExample.java:9)
        at *ErrorExample.recursivePrint(*ErrorExample.java:9)
        ...

根据JVM的初始配置，结果可能会有所不同，但最终将引发*Error 。该示例是一个很好的示例，说明如果不谨慎实施递归可能会引起问题。

如何处理*Error

最简单的解决方案是仔细检查堆栈跟踪并检测行号的重复模式。这些行号表示要递归调用的代码。一旦检测到这些行，就必须仔细检查代码并了解为什么递归永远不会终止。
如果您已验证递归已正确实现，则可以增加堆栈的大小，以允许进行更多的调用。根据安装的Java虚拟机（JVM），默认线程堆栈大小可能等于512KB或1MB 。您可以使用-Xss标志来增加线程堆栈的大小。可以通过项目的配置或通过命令行指定此标志。 -Xss参数的格式为： -Xss<size>[g|G|m|M|k|K]

#11楼

这是一个例子

public static void main(String[] args) {
    System.out.println(add5(1));
}

public static int add5(int a) {
    return add5(a) + 5;
}

从本质上讲，*Error是您尝试执行某项操作时（很可能会自称），并一直持续到无穷大（或直到给出*Error为止）。

add5(a)会调用自身，然后再次调用自身，依此类推。

#12楼

*Error是Java中的运行时错误。

当超过JVM分配的调用堆栈内存量时，将抛出该错误。

抛出*Error常见情况是，由于过度的深度或无限递归导致调用堆栈超过。

例：

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.*Error
at com.program.*.Factorial.factorial(Factorial.java:9)
at com.program.*.Factorial.factorial(Factorial.java:9)
at com.program.*.Factorial.factorial(Factorial.java:9)

在上述情况下，可以通过进行程序更改来避免这种情况。但是，如果程序逻辑正确并且仍然存在，则需要增加堆栈大小。

#13楼

这是java.lang.*Error的典型情况...该方法以递归方式调用自身，而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.*Error
    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中*Error的源代码

上一篇：如果删除了DOM元素，是否还将其侦听器也从内存中删除了？

下一篇：什么时候使用（匿名）内部类确切泄漏？

什么是*Error？

#1楼

#2楼

#3楼

#4楼

#5楼

#6楼

#7楼

#8楼

#9楼

#10楼

#11楼

#12楼

#13楼

Rational.java

Main.java

结果

2021年陕西450分理科能上什么大学？陕西450分的二本学校名单

2021年河北450分理科能上什么大学？附河北450分的公办二本名单

ipad版qq音乐怎么删除歌曲？有什么快速批量方便的方法

考多少分能上西安交通大学？西安交通大学什么档次？好考吗？2021参考

2021年黑龙江450分理科能上什么大学？附黑龙江理科四百分左右的大学名单

2021年浙江450分理科能上什么大学？浙江450能上的二本学校名单

软文推广在营销中的作用是什么？

互联网时代，“带货型”文案长什么样？

为什么SEO要以结果导向？

为什么百度只收录一个首页?