java - spark - talend outofmemoryerror gc overhead limit exceeded




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

Apenas aumente um pouco o tamanho do heap configurando essa opção

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

-Xms1024M -Xmx2048M

Xms - para limite mínimo

Xmx - para limite máximo

Eu recebo esta mensagem de erro enquanto executo meus testes JUnit:

java.lang.OutOfMemoryError: GC overhead limit exceeded

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


Causa para o error

O limite de sobrecarga do GC excedido "indica que o coletor de lixo está em execução o tempo todo e que o programa Java está progredindo muito lentamente.

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

  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 criação de perfil de memória como MAT (Memory analyzer tool), 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 G1 GC é de 90% do tempo de aplicação e 10% do tempo de coleta de lixo
  4. Além de configurar 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 mais algumas perguntas relacionadas sobre o G1GC

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

Coleta de lixo Java G1 em produção

Artigo de rede de rede da Oracle para ajuste fino de GC


Estou trabalhando no Android Studio e encontrei esse erro ao tentar gerar um APK assinado para lançamento. Eu era capaz de construir e testar um APK de depuração sem nenhum problema, mas assim que eu queria construir um APK de lançamento, o processo de compilação seria executado por minutos a fio e, finalmente, terminar com o "Erro java.lang.OutOfMemoryError: GC limite de sobrecarga excedido ". Eu aumentei os tamanhos de heap para a VM e o compilador Android DEX, mas o problema persistiu. Finalmente, depois de muitas horas e canecas de café, descobri que o problema estava no arquivo 'build.gradle' do meu aplicativo - eu tinha o parâmetro 'minifyEnabled' para o tipo de compilação de release 'false', consequentemente executando o Proguard stuffs em código que não passou pelo processo de redução de código (consulte https://developer.android.com/studio/build/shrink-code.html ). Eu mudei o parâmetro 'minifyEnabled' para 'true' e a versão build executada como um sonho :)

Resumindo, tive que alterar o 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
    }
}

//...

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 java 1.6.0_24-b07 Em um Windows 7 de 32 bits.

java -Xloggc: gc.log GarbageCollector

Então olhe para 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, este 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 esse loop ou lidar com código existente que se comporta mal, escolher reutilizar objetos em vez de criar novos pode reduzir o número de vezes que o coletor de lixo fica no caminho ...


O GC lança essa exceção quando muito tempo é gasto na coleta de lixo por um retorno muito pequeno, por exemplo. 98% do tempo de CPU é gasto no GC e menos de 2% do heap é recuperado.

Esse recurso foi projetado para impedir que os aplicativos sejam executados por um período prolongado, enquanto faz pouco ou nenhum progresso porque o heap é muito pequeno.

Você pode desativar isso com a opção de linha de comando -XX:-UseGCOverheadLimit

Mais informações here

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


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

android {
        compileSdkVersion 25
        buildToolsVersion '25.0.1'

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

Para mim, os seguintes passos funcionaram:

  1. Abra o arquivo eclipse.ini
  2. mudança

    -Xms40m
    -Xmx512m

    para

    -Xms512m
    -Xmx1024m
  3. Reinicie o Eclipse

Veja aqui


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

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

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


aumentar javaMaxHeapsize no seu arquivo build.gradle (Module: app)

dexOptions {
    javaMaxHeapSize "1g"
}

para (Adicionar esta linha no gradle)

 dexOptions {
        javaMaxHeapSize "4g"
    }

tente isso

abra o arquivo build.gradle

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




heap-memory