Error java.lang.OutOfMemoryError: límite de sobrecarga del GC excedido

Recibo este mensaje de error cuando ejecuto mis pruebas JUnit:

java.lang.OutOfMemoryError: GC overhead limit exceeded

Sé lo que OutOfMemoryErrores, pero ¿qué significa el límite superior de GC? ¿Como puedo resolver esto?

Este mensaje significa que, por alguna razón, el recolector de basura está tomando una cantidad de tiempo excesiva (por defecto, el 98% de todo el tiempo de CPU del proceso) y recupera muy poca memoria en cada ejecución (por defecto, el 2% del montón).

Esto significa que su programa deja de progresar y está ocupado ejecutando solo la recolección de basura en todo momento.

Para evitar que su aplicación absorba el tiempo de CPU sin hacer nada, la JVM lanza esto Errorpara que tenga la oportunidad de diagnosticar el problema.

Los casos raros en los que he visto que esto sucede es cuando algún código creaba toneladas de objetos temporales y toneladas de objetos con referencias débiles en un entorno que ya tiene mucha memoria.

Consulte la guía de ajuste de Java GC, que está disponible para varias versiones de Java y contiene secciones sobre este problema específico:

• La guía de ajuste de Java 11 tiene secciones dedicadas sobre GC excesivo para diferentes recolectores de basura:
  • para el colector paralelo
  • para el colector concurrente Mark Sweep (CMS)
  • no se menciona esta condición de error específica para el recolector Garbage First (G1).
• Guía de ajuste de Java 8 y su sección GC excesiva
• Guía de ajuste de Java 6 y su sección GC excesiva .

Citando el artículo de Oracle "Java SE 6 HotSpot [tm] Virtual Machine Garbage Collection Tuning" :

Tiempo de GC excesivo y OutOfMemoryError

El recolector paralelo lanzará un OutOfMemoryError si se pasa demasiado tiempo en la recolección de basura: si se gasta más del 98% del tiempo total en la recolección de basura y se recupera menos del 2% del montón, se arrojará un OutOfMemoryError. Esta característica está diseñada para evitar que las aplicaciones se ejecuten durante un período prolongado de tiempo mientras progresa poco o nada porque el montón es demasiado pequeño. Si es necesario, esta característica se puede deshabilitar agregando la opción -XX:-UseGCOverheadLimita la línea de comando.

EDITAR: parece que alguien puede escribir más rápido que yo :)

Si está seguro de que no hay pérdidas de memoria en su programa, intente:

1. Aumente el tamaño del montón, por ejemplo -Xmx1g.
2. Habilite el recopilador simultáneo de pausa baja -XX:+UseConcMarkSweepGC.
3. Reutilice los objetos existentes cuando sea posible para ahorrar algo de memoria.

Si es necesario, la verificación del límite se puede deshabilitar agregando la opción -XX:-UseGCOverheadLimita la línea de comando.

Suele ser el código. Aquí hay un ejemplo simple:

import java.util.*;

public class GarbageCollector {

    public static void main(String... args) {

        System.out.printf("Testing...%n");
        List<Double> list = new ArrayList<Double>();
        for (int outer = 0; outer < 10000; outer++) {

            // list = new ArrayList<Double>(10000); // BAD
            // list = new ArrayList<Double>(); // WORSE
            list.clear(); // BETTER

            for (int inner = 0; inner < 10000; inner++) {
                list.add(Math.random());
            }

            if (outer % 1000 == 0) {
                System.out.printf("Outer loop at %d%n", outer);
            }

        }
        System.out.printf("Done.%n");
    }
}

Usando Java 1.6.0_24-b07 en un Windows 7 de 32 bits.

java -Xloggc:gc.log GarbageCollector

Entonces mira gc.log

• Se activó 444 veces con el método MALO
• Se disparó 666 veces usando el método PEOR
• Se activó 354 veces con el método MEJOR

Ahora concedido, esta no es la mejor prueba o el mejor diseño, pero cuando se enfrenta a una situación en la que no tiene más remedio que implementar dicho ciclo o cuando se trata de código existente que se comporta mal, elegir reducir los objetos en lugar de crear nuevos puede reducir la cantidad de veces que el recolector de basura se interpone en el camino ...

Causa del error de acuerdo con la plataforma Java [8], Guía de solución de problemas de la edición estándar : (énfasis y saltos de línea agregados)

[...] "Límite superior de GC excedido" indica que el recolector de basura se está ejecutando todo el tiempo y que el programa Java está progresando muy lentamente.

Después de una recolección de basura, si el proceso de Java está gastando más de aproximadamente el 98% de su tiempo haciendo recolección de basura y si está recuperando menos del 2% del montón y ha estado haciendo hasta ahora los últimos 5 (tiempo de compilación constante) basura consecutiva colecciones, luego java.lang.OutOfMemoryErrorse arroja a. [...]

1. Aumente el tamaño del montón si el montón actual no es suficiente.
2. Si aún recibe este error después de aumentar la memoria de almacenamiento dinámico, use herramientas de creación de perfiles de memoria como MAT ( herramienta de análisis de memoria), Visual VM, etc. y repare las pérdidas de memoria.
3. Actualice la versión JDK a la última versión (1.8.x) o al menos 1.7.xy use el algoritmo G1GC. . El objetivo de rendimiento para el GC G1 es 90 por ciento de tiempo de aplicación y 10 por ciento de tiempo de recolección de basura.

4. Además de configurar la memoria de almacenamiento dinámico con - Xms1g -Xmx2g, intente

   -XX:+UseG1GC -XX:G1HeapRegionSize=n -XX:MaxGCPauseMillis=m  
   -XX:ParallelGCThreads=n -XX:ConcGCThreads=n
   

Eche un vistazo a algunas preguntas más relacionadas con G1GC

• Recolección de basura y documentación de Java 7 (JDK 7) en G1

• Recolección de basura Java G1 en producción

• Artículo de Oracle technetwork para el ajuste fino de GC

Simplemente aumente un poco el tamaño del montón configurando esta opción en

Ejecutar → Ejecutar configuraciones → Argumentos → Argumentos de VM

-Xms1024M -Xmx2048M

Xms - para límite mínimo

Xmx - para límite máximo

Para mí, los siguientes pasos funcionaron:

1. Abrir el eclipse.iniarchivo

2. Cambio

   -Xms40m
   -Xmx512m

   a

   -Xms512m
   -Xmx1024m

3. Reiniciar Eclipse

Mira aquí

prueba esto

abre el build.gradlearchivo

  android {
        dexOptions {
           javaMaxHeapSize = "4g"
        }
   }

Lo siguiente funcionó para mí. Simplemente agregue el siguiente fragmento:

android {
        compileSdkVersion 25
        buildToolsVersion '25.0.1'

defaultConfig {
        applicationId "yourpackage"
        minSdkVersion 10
        targetSdkVersion 25
        versionCode 1
        versionName "1.0"
        multiDexEnabled true
    }
dexOptions {
        javaMaxHeapSize "4g"
    }
}

aumente javaMaxHeapsize en su archivo build.gradle (Módulo: aplicación)

dexOptions {
    javaMaxHeapSize "1g"
}

a (Agregar esta línea en gradle)

 dexOptions {
        javaMaxHeapSize "4g"
    }

Descripciones de tamaño de almacenamiento dinámico de Java (xms, xmx, xmn)

-Xms size in bytes

Example : java -Xms32m

Establece el tamaño inicial del montón de Java. El tamaño predeterminado es 2097152 (2 MB). Los valores deben ser múltiplos de, y mayores que, 1024 bytes (1 KB). (El indicador -server aumenta el tamaño predeterminado a 32M).

-Xmn size in bytes

Example : java -Xmx2m

Establece el tamaño de almacenamiento dinámico Java inicial para la generación Eden. El valor predeterminado es 640K. (El indicador de servidor aumenta el tamaño predeterminado a 2M).

-Xmx size in bytes

Example : java -Xmx2048m

Establece el tamaño máximo al que puede crecer el montón de Java. El tamaño predeterminado es 64M. (El indicador -server aumenta el tamaño predeterminado a 128M.) El límite máximo de almacenamiento dinámico es de aproximadamente 2 GB (2048MB).

Formato de argumentos de memoria Java (xms, xmx, xmn)

Al configurar el tamaño de almacenamiento dinámico de Java, debe especificar su argumento de memoria utilizando una de las letras "m" o "M" para MB, o "g" o "G" para GB. Su configuración no funcionará si especifica "MB" o "GB". Los argumentos válidos se ven así:

-Xms64m o -Xms64M -Xmx1g o -Xmx1G También puede usar 2048MB para especificar 2GB Además, asegúrese de usar números enteros al especificar sus argumentos. Usar -Xmx512m es una opción válida, pero -Xmx0.5g causará un error.

Esta referencia puede ser útil para alguien.

También puede aumentar la asignación de memoria y el tamaño del montón agregando esto a su gradle.propertiesarchivo:

org.gradle.jvmargs=-Xmx2048M -XX\:MaxHeapSize\=32g

No tiene que ser 2048M y 32g, hazlo tan grande como quieras.

Resuelto:
Sólo tiene que añadir
org.gradle.jvmargs=-Xmx1024m
en
gradle.properties
y si no existe, crear.

Estoy trabajando en Android Studio y encontré este error al intentar generar un APK firmado para su lanzamiento. Pude compilar y probar un APK de depuración sin problemas, pero tan pronto como quise compilar un APK de lanzamiento, el proceso de compilación se ejecutaría durante minutos y finalmente terminaría con el "Error java.lang.OutOfMemoryError: GC límite superior excedido ". Aumenté los tamaños de almacenamiento dinámico tanto para la VM como para el compilador DEX de Android, pero el problema persistió. Finalmente, después de muchas horas y tazas de café, resultó que el problema estaba en mi archivo 'build.gradle' de nivel de aplicación: tenía el parámetro 'minifyEnabled' para el tipo de compilación de lanzamiento establecido en 'falso', por lo tanto, ejecuté cosas de Proguard en código que no ha pasado por el proceso de reducción de código '(consulte https://developer.android.) Cambié el parámetro 'minifyEnabled' a 'verdadero' y la compilación de lanzamiento se ejecutó como un sueño :)

En resumen, tuve que cambiar mi archivo 'build.gradle' de nivel de aplicación de: // ...

buildTypes {
    release {
        minifyEnabled false
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        signingConfig signingConfigs.sign_config_release
    }
    debug {
        debuggable true
        signingConfig signingConfigs.sign_config_debug
    }
}

//...

a

    //...

buildTypes {
    release {
        minifyEnabled true
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        signingConfig signingConfigs.sign_config_release
    }
    debug {
        debuggable true
        signingConfig signingConfigs.sign_config_debug
    }
}

//...

Para aumentar el tamaño de almacenamiento dinámico en IntelliJ IDEA, siga las siguientes instrucciones. Funcionó para mi.

Para usuarios de Windows,

Vaya a la ubicación donde está instalado IDE y busque lo siguiente.

idea64.exe.vmoptions

Edite el archivo y agregue lo siguiente.

-Xms512m
-Xmx2024m
-XX:MaxPermSize=700m
-XX:ReservedCodeCacheSize=480m

Eso es !!

puede intentar realizar cambios en la configuración del servidor haciendo referencia a esta imagen y aumentar el tamaño de la memoria para procesar los cambios del proceso resaltados en amarillo

También puede hacer cambios en Java Heap abriendo cmd-> set _java_opts -Xmx2g
2g (2gigabytes) dependiendo de la complejidad de su programa

intenta usar variables menos constantes y variables temporales

Debe aumentar el tamaño de la memoria en Jdeveloper, vaya a setDomainEnv.cmd .

set WLS_HOME=%WL_HOME%\server    
set XMS_SUN_64BIT=**256**
set XMS_SUN_32BIT=**256**
set XMX_SUN_64BIT=**3072**
set XMX_SUN_32BIT=**3072**
set XMS_JROCKIT_64BIT=**256**
set XMS_JROCKIT_32BIT=**256**
set XMX_JROCKIT_64BIT=**1024**
set XMX_JROCKIT_32BIT=**1024**

if "%JAVA_VENDOR%"=="Sun" (
    set WLS_MEM_ARGS_64BIT=**-Xms256m -Xmx512m**
    set WLS_MEM_ARGS_32BIT=**-Xms256m -Xmx512m**
) else (
    set WLS_MEM_ARGS_64BIT=**-Xms512m -Xmx512m**
    set WLS_MEM_ARGS_32BIT=**-Xms512m -Xmx512m**
)

y

set MEM_PERM_SIZE_64BIT=-XX:PermSize=**256m**
set MEM_PERM_SIZE_32BIT=-XX:PermSize=**256m**

if "%JAVA_USE_64BIT%"=="true" (
    set MEM_PERM_SIZE=%MEM_PERM_SIZE_64BIT%
) else (
    set MEM_PERM_SIZE=%MEM_PERM_SIZE_32BIT%
)

set MEM_MAX_PERM_SIZE_64BIT=-XX:MaxPermSize=**1024m**
set MEM_MAX_PERM_SIZE_32BIT=-XX:MaxPermSize=**1024m**

En Netbeans, puede ser útil diseñar un tamaño de almacenamiento dinámico máximo. Vaya a Ejecutar => Establecer configuración del proyecto => Personalizar . En el Ejecutar de su ventana emergente, vaya a la Opción VM , complete -Xms2048m -Xmx2048m. Podría resolver el problema del tamaño del montón.

Reiniciar mi MacBook solucionó este problema por mí.

No sé si esto sigue siendo relevante o no, pero solo quiero compartir lo que funcionó para mí.

Actualice la versión de kotlin a la última disponible. https://blog.jetbrains.com/kotlin/category/releases/

Y ya está hecho.