Erro java.lang.OutOfMemoryError: limite de sobrecarga do GC excedido

Recebo esta mensagem de erro ao executar meus testes JUnit:

java.lang.OutOfMemoryError: GC overhead limit exceeded

Sei o que OutOfMemoryErroré, mas o que significa o limite de sobrecarga do GC? Como posso resolver isso?

Esta mensagem significa que, por algum motivo, o coletor de lixo está demorando muito tempo (por padrão, 98% de todo o tempo de CPU do processo) e recupera muito pouca memória em cada execução (por padrão, 2% do heap).

Isso significa efetivamente que seu programa para de fazer progresso e está ocupado executando apenas a coleta de lixo o tempo todo.

Para impedir que seu aplicativo absorva o tempo da CPU sem fazer nada, a JVM lança isso Errorpara que você tenha a chance de diagnosticar o problema.

Os casos raros em que eu vi isso acontecer é que algum código criava toneladas de objetos temporários e toneladas de objetos com pouca referência em um ambiente já muito restrito à memória.

Confira o guia de ajuste do Java GC, que está disponível para várias versões do Java e contém seções sobre esse problema específico:

• O guia de ajuste do Java 11 possui seções dedicadas sobre GC excessivo para diferentes coletores de lixo:
  • para o coletor paralelo
  • para o coletor Concurrent Mark Sweep (CMS)
  • não há menção a essa condição de erro específica para o coletor Garbage First (G1).
• Guia de Ajuste do Java 8 e sua Seção Excessiva de GC
• Guia de ajuste do Java 6 e sua seção GC excessivo .

Citando o artigo da Oracle "Ajuste da coleta de lixo da máquina virtual Java SE 6 HotSpot [tm]" :

Tempo excessivo do GC e OutOfMemoryError

O coletor paralelo lançará um OutOfMemoryError se gastar muito tempo na coleta de lixo: se mais de 98% do tempo total for gasto na coleta de lixo e menos de 2% do heap for recuperado, um OutOfMemoryError será lançado. Esse recurso foi projetado para impedir que os aplicativos sejam executados por um longo período de tempo enquanto faz pouco ou nenhum progresso, porque o heap é muito pequeno. Se necessário, esse recurso pode ser desativado adicionando a opção -XX:-UseGCOverheadLimità linha de comando.

EDIT: parece que alguém pode digitar mais rápido do que eu :)

Se você tem certeza de que não há vazamentos de memória no seu programa, tente:

1. Aumente o tamanho da pilha, por exemplo -Xmx1g.
2. Ative o coletor simultâneo de baixa pausa -XX:+UseConcMarkSweepGC.
3. Reutilize objetos existentes, quando possível, para economizar memória.

Se necessário, a verificação do limite pode ser desativada adicionando a opção -XX:-UseGCOverheadLimità linha de comandos.

Geralmente é o código. Aqui está um exemplo simples:

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 o Java 1.6.0_24-b07 em um Windows 7 de 32 bits.

java -Xloggc:gc.log GarbageCollector

Então olha gc.log

• Disparado 444 vezes usando o método BAD
• Disparado 666 vezes usando o método WORSE
• Disparado 354 vezes usando o método BETTER

Agora concedido, esse não é o melhor teste ou o melhor design, mas, quando se depara com uma situação em que você não tem escolha a não ser implementar um loop ou ao lidar com código existente que se comporta mal, optar por reutilizar objetos em vez de criar novos pode reduzir o número de vezes que o coletor de lixo atrapalha ...

Causa do erro de acordo com o Guia de solução de problemas da plataforma Java [8], Standard Edition : (ênfase e quebras de linha adicionadas)

[...] "Limite de sobrecarga da GC excedido" indica que o coletor de lixo está em execução o tempo todo e o programa Java está progredindo muito lentamente.

Após uma coleta de lixo, se o processo Java estiver gastando mais de aproximadamente 98% de seu tempo realizando a coleta de lixo e se estiver recuperando menos de 2% do heap e estiver realizando até agora os últimos 5 (consecutivos em tempo de compilação) lixo consecutivo coleções, então a java.lang.OutOfMemoryErroré lançada. [...]

1. Aumente o tamanho do heap se o heap atual não for suficiente.
2. Se você ainda receber esse erro após aumentar a memória heap, use ferramentas de perfil de memória , como MAT (ferramenta analisadora de memória), Visual VM etc. e corrija vazamentos de memória.
3. Atualize a versão do JDK para a versão mais recente (1.8.x) ou pelo menos 1.7.xe use o algoritmo G1GC. . A meta de taxa de transferência para o GC G1 é 90% de tempo de aplicação e 10% de tempo de coleta de lixo

4. Além de definir a memória heap com - Xms1g -Xmx2g, tente

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

Dê uma olhada em algumas perguntas relacionadas ao G1GC

• Coleta de lixo e documentação do Java 7 (JDK 7) no G1

• Coleta de Lixo Java G1 em Produção

• Artigo Oracle technetwork para ajuste fino de GC

Apenas aumente um pouco o tamanho da pilha configurando esta opção em

Executar → Executar Configurações → Argumentos → Argumentos da VM

-Xms1024M -Xmx2048M

Xms - para limite mínimo

Xmx - para limite máximo

Para mim, as seguintes etapas funcionaram:

1. Abra o eclipse.iniarquivo

2. mudança

   -Xms40m
   -Xmx512m

   para

   -Xms512m
   -Xmx1024m

3. Reinicie o Eclipse

Veja aqui

tente isso

abra o build.gradlearquivo

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

O seguinte funcionou para mim. Basta adicionar o seguinte trecho:

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 no seu arquivo build.gradle (Module: app)

dexOptions {
    javaMaxHeapSize "1g"
}

para (Adicione esta linha em gradle)

 dexOptions {
        javaMaxHeapSize "4g"
    }

Descrições de tamanho de heap Java (xms, xmx, xmn)

-Xms size in bytes

Example : java -Xms32m

Define o tamanho inicial do heap Java. O tamanho padrão é 2097152 (2 MB). Os valores devem ser múltiplos e maiores que 1024 bytes (1 KB). (O sinalizador -server aumenta o tamanho padrão para 32M.)

-Xmn size in bytes

Example : java -Xmx2m

Define o tamanho inicial do heap Java para a geração Eden. O valor padrão é 640K. (O sinalizador -server aumenta o tamanho padrão para 2M.)

-Xmx size in bytes

Example : java -Xmx2048m

Define o tamanho máximo para o qual o heap Java pode crescer. O tamanho padrão é 64M. (O sinalizador -server aumenta o tamanho padrão para 128M.) O limite máximo de heap é de cerca de 2 GB (2048MB).

Formatação de argumentos de memória Java (xms, xmx, xmn)

Ao definir o tamanho do heap Java, especifique seu argumento de memória usando uma das letras "m" ou "M" para MB ou "g" ou "G" para GB. Sua configuração não funcionará se você especificar "MB" ou "GB". Argumentos válidos têm esta aparência:

-Xms64m ou -Xms64M -Xmx1g ou -Xmx1G Também pode usar 2048MB para especificar 2GB Além disso, certifique-se de usar apenas números inteiros ao especificar seus argumentos. Usar -Xmx512m é uma opção válida, mas -Xmx0.5g causará um erro.

Esta referência pode ser útil para alguém.

Você também pode aumentar a alocação de memória e o tamanho da pilha adicionando isso ao seu gradle.propertiesarquivo:

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

Não precisa ser 2048M e 32g, faça o tamanho que você quiser.

Resolvido:
Basta adicionar
org.gradle.jvmargs=-Xmx1024m
em
gradle.properties
e se ele não existir, criá-la.

Estou trabalhando no Android Studio e encontrei esse erro ao tentar gerar um APK assinado para lançamento. Consegui criar e testar um APK de depuração sem problemas, mas assim que quisesse criar um APK de lançamento, o processo de compilação seria executado por minutos a fio e, finalmente, terminaria com o "Erro java.lang.OutOfMemoryError: GC limite superior excedido ". Aumentei os tamanhos de heap para o VM e o compilador Android DEX, mas o problema persistiu. Finalmente, depois de muitas horas e canecas de café, constatou-se que o problema estava no arquivo 'build.gradle' no nível do aplicativo - eu tinha o parâmetro 'minifyEnabled' para o tipo de compilação do release definido como 'false', consequentemente executando os itens Proguard no código que não passou pelo processo de redução de código '(consulte https://developer.android.) Alterei o parâmetro 'minifyEnabled' para 'true' e a compilação do release foi executada como um sonho :)

Em resumo, tive que alterar meu arquivo 'build.gradle' no nível do aplicativo 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
    }
}

//...

para

    //...

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 o tamanho da pilha no IntelliJ IDEA, siga as seguintes instruções. Funcionou para mim.

Para usuários do Windows,

Vá para o local em que o IDE está instalado e procure o seguinte.

idea64.exe.vmoptions

Edite o arquivo e adicione o seguinte.

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

É isso !!

você pode tentar fazer alterações na configuração do servidor consultando esta imagem e aumentando o tamanho da memória para processar as alterações do processo destacadas em amarelo

você também pode fazer alterações no heap java abrindo cmd-> set _java_opts -Xmx2g
2g (2gigabytes), dependendo da complexidade do seu programa

tente usar variáveis ​​e variáveis ​​temporárias menos constantes

Você precisa aumentar o tamanho da memória no Jdeveloper, vá para 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**
)

e

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**

No Netbeans, pode ser útil criar um tamanho máximo de heap. Vá para Executar => Definir configuração do projeto => Personalizar . Na janela Executar da sua janela exibida, vá para VM Option , preencha -Xms2048m -Xmx2048m. Pode resolver o problema do tamanho da pilha.

A reinicialização do meu MacBook corrigiu esse problema para mim.

Não sei se isso ainda é relevante ou não, mas quero apenas compartilhar o que funcionou para mim.

Atualize a versão do kotlin para a versão mais recente disponível. https://blog.jetbrains.com/kotlin/category/releases/

e está feito.