Was ist ein StackOverflowError?

Was ist ein StackOverflowError , was verursacht es und wie soll ich damit umgehen?

Parameter und lokale Variablen werden auf dem Stapel zugewiesen (bei Referenztypen befindet sich das Objekt auf dem Heap und eine Variable im Stapel verweist auf dieses Objekt auf dem Heap). Der Stapel befindet sich normalerweise am oberen Ende Ihres Adressraums und bewegt sich, wenn er aufgebraucht ist, zum unteren Rand des Adressraums (dh gegen Null).

Ihr Prozess hat auch einen Haufen , der sich am unteren Ende Ihres Prozesses befindet. Wenn Sie Speicher zuweisen, kann dieser Heap zum oberen Ende Ihres Adressraums hin wachsen. Wie Sie sehen können, besteht die Möglichkeit, dass der Haufen mit dem Stapel "kollidiert" (ein bisschen wie bei tektonischen Platten !!!).

Die häufigste Ursache für einen Stapelüberlauf ist ein schlechter rekursiver Aufruf . In der Regel wird dies verursacht, wenn Ihre rekursiven Funktionen nicht die richtige Beendigungsbedingung haben und sich daher für immer selbst aufrufen. Wenn die Beendigungsbedingung in Ordnung ist, kann dies dadurch verursacht werden, dass zu viele rekursive Aufrufe erforderlich sind, bevor sie erfüllt werden.

Mit der GUI-Programmierung ist es jedoch möglich, eine indirekte Rekursion zu generieren . Beispielsweise verarbeitet Ihre App möglicherweise Malmeldungen und ruft während der Verarbeitung eine Funktion auf, die das System veranlasst, eine weitere Malmeldung zu senden. Hier haben Sie sich nicht explizit angerufen, aber das OS / VM hat es für Sie erledigt.

Um mit ihnen fertig zu werden, müssen Sie Ihren Code überprüfen. Wenn Sie Funktionen haben, die sich selbst aufrufen, überprüfen Sie, ob Sie eine Beendigungsbedingung haben. Wenn ja, überprüfen Sie, ob Sie beim Aufrufen der Funktion mindestens eines der Argumente geändert haben. Andernfalls wird die rekursiv aufgerufene Funktion nicht sichtbar geändert, und die Beendigungsbedingung ist unbrauchbar. Beachten Sie auch, dass Ihrem Stack-Speicher möglicherweise der Speicherplatz ausgeht, bevor eine gültige Beendigungsbedingung erreicht wird. Stellen Sie daher sicher, dass Ihre Methode Eingabewerte verarbeiten kann, die rekursivere Aufrufe erfordern.

Wenn Sie keine offensichtlichen rekursiven Funktionen haben, überprüfen Sie, ob Sie Bibliotheksfunktionen aufrufen, die indirekt dazu führen, dass Ihre Funktion aufgerufen wird (wie im obigen impliziten Fall).

Um dies zu beschreiben, lassen Sie uns zunächst verstehen, wie lokale Variablen und Objekte gespeichert werden.

Lokale Variablen werden im Stapel gespeichert :

Wenn Sie sich das Bild ansehen, sollten Sie verstehen können, wie die Dinge funktionieren.

Wenn ein Funktionsaufruf von einer Java-Anwendung aufgerufen wird, wird dem Aufrufstapel ein Stapelrahmen zugewiesen. Der Stapelrahmen enthält die Parameter der aufgerufenen Methode, ihre lokalen Parameter und die Rücksprungadresse der Methode. Die Rücksprungadresse gibt den Ausführungspunkt an, von dem aus die Programmausführung fortgesetzt werden soll, nachdem die aufgerufene Methode zurückgegeben wurde. Wenn kein Platz für einen neuen Stapelrahmen vorhanden ist, StackOverflowErrorwird dieser von der Java Virtual Machine (JVM) ausgelöst.

Der häufigste Fall, der möglicherweise den Stapel einer Java-Anwendung erschöpfen kann, ist die Rekursion. Bei der Rekursion ruft sich eine Methode während ihrer Ausführung auf. Rekursion wird als leistungsstarke Allzweckprogrammiertechnik angesehen, muss jedoch mit Vorsicht angewendet werden, um dies zu vermeiden StackOverflowError.

Ein Beispiel für das Werfen von a StackOverflowErrorist unten dargestellt:

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);
  }
}

In diesem Beispiel definieren wir eine rekursive Methode, recursivePrintdie eine Ganzzahl druckt und sich dann selbst aufruft, wobei die nächste aufeinanderfolgende Ganzzahl ein Argument ist. Die Rekursion endet, bis wir 0als Parameter übergeben. In unserem Beispiel haben wir jedoch den Parameter von 1 und seinen zunehmenden Followern übergeben. Folglich wird die Rekursion niemals beendet.

Eine Beispielausführung unter Verwendung des -Xss1MFlags, das die Größe des Thread-Stapels auf 1 MB angibt, ist unten dargestellt:

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)
        ...

Abhängig von der ursprünglichen Konfiguration der JVM können die Ergebnisse unterschiedlich sein, aber eventuell StackOverflowErrorwerden sie geworfen. Dieses Beispiel ist ein sehr gutes Beispiel dafür, wie Rekursion Probleme verursachen kann, wenn sie nicht mit Vorsicht implementiert wird.

Umgang mit dem StackOverflowError

1. Die einfachste Lösung besteht darin, die Stapelspur sorgfältig zu untersuchen und das sich wiederholende Muster der Zeilennummern zu erkennen. Diese Zeilennummern geben den Code an, der rekursiv aufgerufen wird. Sobald Sie diese Zeilen erkannt haben, müssen Sie Ihren Code sorgfältig prüfen und verstehen, warum die Rekursion niemals beendet wird.

2. Wenn Sie überprüft haben, dass die Rekursion korrekt implementiert ist, können Sie den Stapel vergrößern, um eine größere Anzahl von Aufrufen zu ermöglichen. Abhängig von der installierten Java Virtual Machine (JVM) kann die Standardgröße des Thread-Stacks entweder 512 KB oder 1 MB betragen . Sie können die Thread-Stapelgröße mithilfe des -XssFlags erhöhen . Dieses Flag kann entweder über die Projektkonfiguration oder über die Befehlszeile angegeben werden. Das Format des -XssArguments lautet: -Xss<size>[g|G|m|M|k|K]

Wenn Sie eine Funktion haben wie:

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

Dann ruft sich foo () immer weiter auf und wird immer tiefer. Wenn der Speicherplatz, der zum Verfolgen der Funktionen verwendet wird, gefüllt ist, wird der Stapelüberlauffehler angezeigt.

Stapelüberlauf bedeutet genau das: Ein Stapel läuft über. Normalerweise enthält das Programm einen Stapel, der Variablen und Adressen für den lokalen Bereich enthält, an die zurückgegeben werden soll, wenn die Ausführung einer Routine endet. Dieser Stapel ist in der Regel ein fester Speicherbereich irgendwo im Speicher, daher ist er begrenzt, wie viel er Werte enthalten kann.

Wenn der Stapel leer ist, können Sie nicht platzen. Andernfalls wird ein Stapelunterlauffehler angezeigt.

Wenn der Stapel voll ist, können Sie nicht pushen. Andernfalls wird ein Stapelüberlauffehler angezeigt.

Der Stapelüberlauf wird also dort angezeigt, wo Sie dem Stapel zu viel zuweisen. Zum Beispiel in der erwähnten Rekursion.

Einige Implementierungen optimieren einige Formen von Rekursionen. Insbesondere Schwanzrekursion. Schwanzrekursive Routinen sind eine Form von Routinen, bei denen der rekursive Aufruf als letzte Aufgabe der Routine angezeigt wird. Ein solcher Routineaufruf wird einfach in einen Sprung reduziert.

Einige Implementierungen gehen so weit, dass sie ihre eigenen Stapel für die Rekursion implementieren. Daher können sie die Rekursion fortsetzen, bis dem System der Speicher ausgeht.

Am einfachsten könnten Sie versuchen, die Stapelgröße zu erhöhen, wenn Sie können. Wenn Sie dies jedoch nicht tun können, ist es am zweitbesten zu prüfen, ob es etwas gibt, das eindeutig den Stapelüberlauf verursacht. Probieren Sie es aus, indem Sie vor und nach dem Aufruf etwas in die Routine drucken. Dies hilft Ihnen, die fehlerhafte Routine herauszufinden.

Ein Stapelüberlauf wird normalerweise aufgerufen, indem Funktionsaufrufe zu tief verschachtelt werden (besonders einfach bei Verwendung der Rekursion, dh einer Funktion, die sich selbst aufruft) oder indem eine große Menge an Speicher auf dem Stapel zugewiesen wird, wo die Verwendung des Heaps besser geeignet wäre.

Wie Sie sagen, müssen Sie Code anzeigen. :-)

Ein Stapelüberlauffehler tritt normalerweise auf, wenn Ihre Funktionsaufrufe zu tief verschachtelt sind. Im Golf- Thread "Stapelüberlaufcode" finden Sie einige Beispiele dafür (obwohl bei dieser Frage die Antworten absichtlich einen Stapelüberlauf verursachen).

Die häufigste Ursache für Stapelüberläufe ist eine zu tiefe oder unendliche Rekursion . Wenn dies Ihr Problem ist, kann dieses Tutorial zur Java-Rekursion helfen, das Problem zu verstehen.

StackOverflowErrorist zum Stapel wie OutOfMemoryErrorzum Haufen.

Ungebundene rekursive Aufrufe führen dazu, dass der Stapelspeicher belegt wird.

Das folgende Beispiel ergibt StackOverflowError:

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

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

StackOverflowError ist vermeidbar, wenn rekursive Aufrufe begrenzt sind, um zu verhindern, dass die Gesamtsumme unvollständiger speicherinterner Aufrufe (in Bytes) die Stapelgröße (in Bytes) überschreitet.

Hier ist ein Beispiel eines rekursiven Algorithmus zum Umkehren einer einfach verknüpften Liste. Auf einem Laptop mit der folgenden Spezifikation (4 G-Speicher, Intel Core i5 2,3-GHz-CPU, 64-Bit-Windows 7) tritt bei dieser Funktion ein StackOverflow-Fehler für eine verknüpfte Liste mit einer Größe nahe 10.000 auf.

Mein Punkt ist, dass wir die Rekursion mit Bedacht anwenden sollten, wobei wir immer die Größe des Systems berücksichtigen sollten. Oft kann die Rekursion in ein iteratives Programm konvertiert werden, das besser skaliert. (Eine iterative Version desselben Algorithmus befindet sich am Ende der Seite. Sie kehrt eine einfach verknüpfte Liste mit einer Größe von 1 Million in 9 Millisekunden um.)

    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);
}

Iterative Version desselben Algorithmus:

    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);
}

A StackOverflowErrorist ein Laufzeitfehler in Java.

Es wird ausgelöst, wenn die von JVM zugewiesene Menge an Call-Stack-Speicher überschritten wird.

Ein häufiger Fall eines StackOverflowErrorWurfs ist, wenn der Aufrufstapel aufgrund einer zu tiefen oder unendlichen Rekursion überschritten wird.

Beispiel:

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");
    }
}

Stapelspur:

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)

Im obigen Fall kann dies durch programmatische Änderungen vermieden werden. Wenn die Programmlogik jedoch korrekt ist und dennoch auftritt, muss die Stapelgröße erhöht werden.

Dies ist ein typischer Fall von java.lang.StackOverflowError... Die Methode ruft sich rekursiv ohne Exit in auf doubleValue().floatValue() usw.

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;
                }
            }
        }
    }

Ergebnis

    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)

Hier ist der Quellcode von StackOverflowErrorin OpenJDK 7

In einer Krise führt die Situation "Unten" zu einem Stapelüberlauffehler.

public class Example3 {

public static void main(String[] args) {

    main(new String[1]);

}

}}

Hier ist ein Beispiel

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

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

Ein StackOverflowError ist im Grunde genommen, wenn Sie versuchen, etwas zu tun, das sich höchstwahrscheinlich selbst aufruft und unendlich weitergeht (oder bis es einen StackOverflowError gibt).

add5(a) ruft sich selbst an und ruft sich dann erneut an und so weiter.

Der Begriff "Stapelüberlauf (Überlauf)" wird häufig verwendet, ist jedoch eine falsche Bezeichnung. Angriffe überlaufen den Stapel nicht, sondern puffern auf dem Stapel.

- aus Vorlesungsfolien von Prof. Dr. Dieter Gollmann