¿Qué es un StackOverflowError?

¿Qué es un StackOverflowError, qué lo causa y cómo debo tratar con ellos?

Los parámetros y las variables locales se asignan en la pila (con los tipos de referencia, el objeto vive en el montón y una variable en la pila hace referencia a ese objeto en el montón). La pila normalmente vive en el extremo superior de su espacio de direcciones y, a medida que se agota, se dirige hacia la parte inferior del espacio de direcciones (es decir, hacia cero).

Su proceso también tiene un montón , que vive en el extremo inferior de su proceso. A medida que asigna memoria, este montón puede crecer hacia el extremo superior de su espacio de direcciones. Como se puede ver, hay un potencial para el montón de "chocan" con la pila (un poco como placas tectónicas !!!).

La causa común de un desbordamiento de pila es una mala llamada recursiva . Por lo general, esto se produce cuando sus funciones recursivas no tienen la condición de terminación correcta, por lo que termina llamándose para siempre. O cuando la condición de terminación es buena, puede ser causada por requerir demasiadas llamadas recursivas antes de cumplirla.

Sin embargo, con la programación GUI, es posible generar una recursión indirecta . Por ejemplo, su aplicación puede estar manejando mensajes de pintura y, mientras los procesa, puede llamar a una función que hace que el sistema envíe otro mensaje de pintura. Aquí no te has llamado explícitamente a ti mismo, pero el OS / VM lo ha hecho por ti.

Para lidiar con ellos, deberá examinar su código. Si tiene funciones que se llaman a sí mismas, compruebe que tiene una condición de terminación. Si es así, verifique que al llamar a la función haya modificado al menos uno de los argumentos, de lo contrario no habrá cambios visibles para la función llamada recursivamente y la condición de terminación es inútil. También tenga en cuenta que su espacio de pila puede quedarse sin memoria antes de alcanzar una condición de terminación válida, por lo tanto, asegúrese de que su método pueda manejar los valores de entrada que requieren más llamadas recursivas.

Si no tiene funciones recursivas obvias, verifique si está llamando a alguna función de biblioteca que indirectamente hará que se llame a su función (como el caso implícito anterior).

Para describir esto, primero comprendamos cómo se almacenan las variables y los objetos locales .

Las variables locales se almacenan en la pila :

Si mirabas la imagen, deberías poder entender cómo funcionan las cosas.

Cuando una aplicación Java invoca una llamada de función, se asigna un marco de pila en la pila de llamadas. El marco de la pila contiene los parámetros del método invocado, sus parámetros locales y la dirección de retorno del método. La dirección de retorno indica el punto de ejecución desde el cual, la ejecución del programa continuará después de que regrese el método invocado. Si no hay espacio para un nuevo marco de pila, StackOverflowErrorJava Virtual Machine (JVM) lo lanza.

El caso más común que posiblemente puede agotar la pila de una aplicación Java es la recursividad. En la recursividad, un método se invoca durante su ejecución. La recursión se considera una técnica de programación poderosa de uso general, pero debe usarse con precaución para evitarla StackOverflowError.

A continuación se muestra un ejemplo de tirar un 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);
  }
}

En este ejemplo, definimos un método recursivo, llamado recursivePrintque imprime un número entero y luego se llama a sí mismo, con el siguiente número entero sucesivo como argumento. La recursión termina hasta que pasamos 0como parámetro. Sin embargo, en nuestro ejemplo, pasamos el parámetro de 1 y sus seguidores crecientes, por lo tanto, la recursión nunca terminará.

A continuación se muestra una ejecución de muestra, utilizando el -Xss1Mindicador que especifica el tamaño de la pila de subprocesos para que sea igual a 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)
        ...

Dependiendo de la configuración inicial de la JVM, los resultados pueden diferir, pero eventualmente StackOverflowErrorse arrojarán. Este ejemplo es un muy buen ejemplo de cómo la recursión puede causar problemas, si no se implementa con precaución.

Cómo lidiar con el StackOverflowError

1. La solución más simple es inspeccionar cuidadosamente el seguimiento de la pila y detectar el patrón repetitivo de los números de línea. Estos números de línea indican el código que se llama recursivamente. Una vez que detecte estas líneas, debe inspeccionar cuidadosamente su código y comprender por qué la recursión nunca termina.

2. Si ha verificado que la recursión se implementa correctamente, puede aumentar el tamaño de la pila para permitir un mayor número de invocaciones. Dependiendo de la máquina virtual Java (JVM) instalada, el tamaño predeterminado de la pila de subprocesos puede ser igual a 512 KB o 1 MB . Puede aumentar el tamaño de la pila de subprocesos utilizando la -Xssbandera. Este indicador se puede especificar mediante la configuración del proyecto o mediante la línea de comando. El formato del -Xssargumento es: -Xss<size>[g|G|m|M|k|K]

Si tiene una función como:

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

Luego, foo () seguirá llamándose a sí mismo, cada vez más profundo, y cuando se llena el espacio utilizado para realizar un seguimiento de las funciones en las que se encuentra, se obtiene el error de desbordamiento de pila.

El desbordamiento de pila significa exactamente eso: una pila se desborda. Por lo general, hay una pila en el programa que contiene variables de ámbito local y direcciones donde regresar cuando finaliza la ejecución de una rutina. Esa pila tiende a ser un rango de memoria fijo en algún lugar de la memoria, por lo tanto, está limitado cuánto puede contener valores.

Si la pila está vacía, no puede aparecer, si lo hace, obtendrá un error de desbordamiento de pila.

Si la pila está llena, no puede empujar, si lo hace, obtendrá un error de desbordamiento de pila.

Entonces, el desbordamiento de la pila aparece donde se asigna demasiado a la pila. Por ejemplo, en la recursión mencionada.

Algunas implementaciones optimizan algunas formas de recursiones. Recurrencia de la cola en particular. Las rutinas recursivas de cola son formas de rutinas donde la llamada recursiva aparece como una cosa final de lo que hace la rutina. Tal llamada de rutina simplemente se reduce a un salto.

Algunas implementaciones llegan a implementar sus propias pilas para la recursividad, por lo tanto, permiten que la recursión continúe hasta que el sistema se quede sin memoria.

Lo más fácil que podría intentar sería aumentar el tamaño de su pila si puede. Sin embargo, si no puede hacer eso, la segunda mejor opción sería mirar si hay algo que claramente causa el desbordamiento de la pila. Pruébelo imprimiendo algo antes y después de la llamada en la rutina. Esto le ayuda a descubrir la rutina fallida.

Un desbordamiento de la pila generalmente se llama mediante llamadas a funciones de anidamiento demasiado profundas (especialmente fácil cuando se usa la recursión, es decir, una función que se llama a sí misma) o al asignar una gran cantidad de memoria en la pila donde sería más apropiado usar el montón.

Como usted dice, necesita mostrar un código. :-)

Un error de desbordamiento de pila generalmente ocurre cuando las llamadas a funciones anidan demasiado. Vea el hilo de Stack Overflow Code Golf para ver algunos ejemplos de cómo sucede esto (aunque en el caso de esa pregunta, las respuestas intencionalmente causan un desbordamiento de la pila).

La causa más común de desbordamientos de pila es una recursión excesivamente profunda o infinita . Si este es su problema, este tutorial sobre Java Recursion podría ayudarlo a comprender el problema.

StackOverflowError es a la pila como OutOfMemoryError para el montón.

Las llamadas recursivas ilimitadas dan como resultado que se agote el espacio de la pila.

El siguiente ejemplo produce StackOverflowError:

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

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

StackOverflowError es evitable si las llamadas recursivas están limitadas para evitar que el total agregado de llamadas incompletas en memoria (en bytes) exceda el tamaño de la pila (en bytes).

Aquí hay un ejemplo de un algoritmo recursivo para invertir una lista vinculada individualmente. En una computadora portátil con la siguiente especificación (memoria 4G, CPU Intel Core i5 2.3GHz, Windows 7 de 64 bits), esta función se encontrará con el error StackOverflow para una lista vinculada de tamaño cercano a 10,000.

Mi punto es que deberíamos usar la recursividad con prudencia, siempre teniendo en cuenta la escala del sistema. A menudo, la recursión se puede convertir en un programa iterativo, que se escala mejor. (Una versión iterativa del mismo algoritmo se da en la parte inferior de la página, invierte una lista individualmente vinculada de tamaño 1 millón en 9 milisegundos).

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

Versión iterativa del mismo algoritmo:

    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 StackOverflowErrores un error de tiempo de ejecución en Java.

Se lanza cuando se excede la cantidad de memoria de pila de llamadas asignada por JVM.

Un caso común de StackOverflowErrorser arrojado es cuando la pila de llamadas excede debido a una recursión excesiva o infinita excesiva.

Ejemplo:

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

Seguimiento de pila:

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)

En el caso anterior, se puede evitar haciendo cambios programáticos. Pero si la lógica del programa es correcta y aún se produce, entonces debe aumentar el tamaño de la pila.

Este es un caso típico de java.lang.StackOverflowError... El método se llama recursivamente a sí mismo sin salir doubleValue(),floatValue() , etc.

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

Resultado

    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)

Aquí está el código fuente de StackOverflowErrorOpenJDK 7

En una crisis, la situación a continuación traerá un error de desbordamiento de pila.

public class Example3 {

public static void main(String[] args) {

    main(new String[1]);

}

}

Aquí hay un ejemplo

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

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

Básicamente, un StackOverflowError es cuando intentas hacer algo, que probablemente se llama a sí mismo, y continúa por el infinito (o hasta que da un StackOverflowError).

add5(a) se llamará a sí mismo, y luego se llamará a sí mismo nuevamente, y así sucesivamente.

El término "desbordamiento de pila (desbordamiento)" se usa a menudo pero es un nombre inapropiado; Los ataques no desbordan la pila, sino que los amortigua en la pila.

- de las diapositivas del profesor Dr. Dieter Gollmann