Die java-Fehlermeldung.lang.OutOfMemoryError: GC overhead limit exceeded

Bekomme ich diese Fehlermeldung wie führe ich meine JUnit-tests:

java.lang.OutOfMemoryError: GC overhead limit exceeded

Ich weiß, was ein OutOfMemoryError ist, aber was bedeutet GC overhead limit bedeuten? Wie kann ich dieses Problem lösen?

Das klingt sehr interessant. Ich würde gerne, wenn jemand posten könnte einige code, der generiert diese.
Ich habe einfach das problem gefunden, die dazu führten, dass zu viel memory-Nutzung, in der Nähe der Grenze des Heaps. Eine einfache Lösung könnte einfach sein, zu geben mehr Heap-Speicher für die Java-Engine (-Xmx), aber dies hilft nur, wenn die Anwendung braucht genau so viel Speicher, wie die heap-limit, bevor Sie eingestellt wurde.
ich hatte hier eine Antwort überprüfen Sie, ob es hilft, stackoverflow.com/questions/11091516/...
Beachten Sie, dass es mehrere OutOfMemoryError Szenarien für die Erhöhung der heap nicht eine gültige Lösung: ausführen von nativen threads und läuft aus der perm-gen (die ist getrennt vom heap) sind zwei Beispiele. Seien Sie vorsichtig über die Herstellung übermäßig breiten Aussagen über OutOfMemoryErrors; es gibt eine überraschend vielfältige Reihe von Dingen, die verursachen können, Sie.
Wie hast du das Problem lösen??

InformationsquelleAutor Mnementh | 2009-09-08

689

Diese Meldung bedeutet, dass für einige Grund, warum der garbage collector ist die Einnahme eine übermäßige Menge an Zeit (standardmäßig 98% der CPU-Zeit des Prozesses) und erholt sich nur sehr wenig Speicher in jeder Ausführung (standardmäßig 2% des Haufens).

Dies bedeutet effektiv, dass Ihr Programm aufhört, jeglichen Fortschritt und ist damit beschäftigt, auf dem nur der garbage collection-zu jeder Zeit.

Um zu verhindern, dass Ihre Anwendung von einweichen bis die CPU-Zeit, ohne sich etwas getan, die JVM wirft diese Error so dass Sie die chance haben, bei der Diagnose des Problems.

Den seltenen Fällen, wo ich habe gesehen, das geschehen ist, wo einige code erzeugen Tonnen von temporären Objekten und Tonnen von schwach-referenzierte Objekte in einem bereits sehr Speicher-eingeschränkten Umgebung.

Check-out dieser Artikel für details (insbesondere dieses Teil).

Ist es richtig zu fassen Sie Ihre Antwort wie folgt: "Es ist wie eine" Java Heap space " - Fehler. Geben Sie mehr Speicher mit dem -Xmx." ?
Nein, das wäre nicht richtig. Während Sie ihm mehr Arbeitsspeicher könnte reduzieren Sie das problem, Sie sollte auch einen Blick auf den code und sehen Sie, warum es produziert so viel Müll, und warum dein code gleitet knapp unter der "out of memory" - Marke. Es ist oft ein Zeichen von kaputt-code.
Danke, es scheint Oracle nicht wirklich, dass eine gute Daten-migration, brachen Sie den link.
Sie hatte mich an "Danke, es scheint, Oracle ist nicht gut"
wenn mehrere Anwendungen laufen in derselben JVM, dann ja, Sie können sich leicht gegenseitig beeinflussen. Es wird schwer, zu sagen, was man verursacht. Die Trennung der Anwendungen in unterschiedliche JVMs könnte die einfachste Lösung sein.

InformationsquelleAutor Joachim Sauer
190

GC löst diese Ausnahme aus, wenn zu viel Zeit wird damit verbracht, in die garbage collection für zu wenig zurück, zB. 98% der CPU-Zeit auf GC und weniger als 2% der heap wiederhergestellt ist.

Diese Funktion soll verhindern, dass Anwendungen aus, die für einen längeren Zeitraum während der Herstellung wenig oder gar keine Fortschritte, weil der heap zu klein ist.

Können Sie dies ausschalten mit der Befehlszeile-option
-XX:-UseGCOverheadLimit

Mehr info hier

EDIT: wie jemand aussieht, können Sie jetzt schneller Tippen als ich 🙂

"Sie können dies ausschalten..." aber die OP höchstwahrscheinlich nicht tun soll.
Können Sie mir sagen, den Unterschied zwischen "XX" und "-Xmx"? Ich war in der Lage, es zu deaktivieren mit dem "-Xmx" - option zu.
Antworten auf eine sehr alte Kommentar hier, aber... @Bart Die -XX: zu Beginn mehrere Optionen für die Befehlszeile ist ein Kennzeichen der Arten, die angibt, dass diese option sehr VM-spezifischen und instabilen (ohne Vorankündigung geändert werden in zukünftigen Versionen). In jedem Fall, die -XX:-UseGCOverheadLimit flag erzählt die VM zu deaktivieren, GC overhead limit-Prüfung (eigentlich "ausgeschaltet"), in der Erwägung, dass Ihre -Xmx Befehl lediglich erhöhte sich der heap. Im letzteren Fall ist der GC overhead-Prüfung war noch ausführen, es klingt wie eine größere heap gelöst GC-Prügel-Probleme in deinem Fall (das wird nicht immer helfen).
In meiner Anwendung (Lesen in einem großen Excel-Datei in Talend) dies nicht funktioniert und von anderen Benutzern Erklärung, die ich verstehen, warum. Diese nur deaktiviert, der Fehler aber das problem besteht weiterhin, und Ihre Anwendung wird nur verbringen die meiste Zeit mit dem Umgang mit GC. Unser server hatte viel RAM also habe ich die Vorschläge von Vitalii zur Erhöhung der heap-Größe.
Später werden Sie diese Fehlermeldung erhalten, wenn Ihre Anwendung ist datenintensiv ist, das löschen des Speichers und weichen Daten-Leck ist der beste Weg - erfordert aber etwas Zeit.

InformationsquelleAutor dave
78

Wenn Sie sicher sind, dass keine memory leaks in Ihrem Programm versuchen:
1. Erhöhung der heap-Größe, zum Beispiel -Xmx1g.
2. Aktivieren Sie die concurrent low pause collector -XX:+UseConcMarkSweepGC.
3. Die Wiederverwendung bestehender Objekte wenn möglich etwas Speicher sparen.
Falls erforderlich, die limit check kann deaktiviert werden, indem die option -XX:-UseGCOverheadLimit auf der Kommandozeile.

Ich widerspreche der Dritten Beratung. Die Wiederverwendung bestehender Objekte, die nicht speichern Speicher (nicht Leck alten-Objekte speichern Speicher 🙂 Außerdem ist "die Wiederverwendung von vorhandenen Objekts" war eine Praxis, die zu entlasten, GC Druck. Aber es ist NICHT IMMER eine gute Idee: mit modernen GC, wir sollten Situationen vermeiden, in denen alte Gegenstände halten neue, denn es kann brechen einige Lokalität Annahmen...

InformationsquelleAutor Vitalii Fedorenko
38

Es ist in der Regel der code. Hier ein einfaches Beispiel:
```
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");
    }
}
```
Verwendung von java 1.6.0_24-b07 Auf einem Windows7 32 bit.

java -Xloggc:gc.log-GarbageCollector

Dann schau bei gc.melden Sie
- Ausgelöst 444 Zeiten SCHLECHTE Methode
- Ausgelöst 666 Zeiten mit SCHLECHTER Methode
- Ausgelöst 354 mal mit BESSEREN Methode
Zugegeben, dies ist nicht der beste test, oder das beste design, aber wenn Sie mit einer situation, wo Sie keine Wahl haben, aber die Umsetzung einer solchen Schleife oder beim Umgang mit bestehender code, der sich schlecht benimmt, Wahl der Wiederverwendung Objekte, statt neue zu erstellen können, reduzieren Sie die Anzahl der Zeiten, die der garbage collector in die Quere kommt...

Bitte klären: Wenn Sie sagen "Ausgelöst, n-mal", bedeutet das, dass eine regelmäßige GC passiert ist n-mal, oder, dass die "GC overhead limit exceeded" - Fehlermeldung des OP passiert ist n-mal?

InformationsquelleAutor Mike
28

Ursache für die Fehler

GC overhead limit exceeded" bedeutet, dass der garbage collector läuft die ganze Zeit und Java-Programm macht sehr langsame Fortschritte.

Nach einer garbage collection, wenn die Java-Prozess verbringt mehr als etwa 98% seiner Zeit mit garbage collection und wenn es erholt sich weniger als 2% der heap-und wurde damit weit über die letzten 5 (compile-Zeit-Konstante) aufeinander folgende Müll-Sammlungen, dann eine java.lang.OutOfMemoryError geworfen wird
1. Erhöhung der heap-Größe, wenn der aktuelle heap ist nicht genug.
2. Wenn Sie weiterhin diese Fehlermeldung erhalten, nach der Erhöhung von heap-Speicher, Speicher profiling-tools wie MAT ( Memory analyzer), Visual VM etc und beheben von Speicherlecks.
3. Upgrade JDK-version auf neueste version ( 1.8.x) oder mindestens 1.7.x und verwenden G1GC Algorithmus. . Der Durchsatz Ziel für den G1 GC zu 90 Prozent-Anwendung Zeit und 10 Prozent garbage collection Zeit
4. Abgesehen von der Einstellung der heap-Speicher mit - Xms1g -Xmx2g versuchen
```
-XX:+UseG1GC -XX:G1HeapRegionSize=n -XX:MaxGCPauseMillis=m  
-XX:ParallelGCThreads=n -XX:ConcGCThreads=n
```
Haben Sie einen Blick auf einige weitere Fragen betreffend G1GC

Java 7 (JDK 7) Müll-Sammlung und Dokumentation auf dem G1

Java G1 garbage collection in der Produktion

Oracle technetwork Artikel für GC Feintuning

InformationsquelleAutor Ravindra babu
26

Erhöhen nur die heap-Größe ein wenig von der Einstellung dieser option in

Run → Run Configurations → Arguments → VM arguments
```
-Xms1024M -Xmx2048M
```
Xms - für minimale Grenze

Xmx - für maximale Grenze

Die android-apps nicht haben arguments tab...was sollten wir tun, um dies zu erreichen?
sorry @BlazeTama keine Ahnung von android...ich habe nicht versucht, dass noch...
Welches tool ist die Antwort? Das war nicht eine Eclipse-Frage.
Es gibt keine "Bagatellgrenze". -Xms ist die ursprüngliche Größe.
Was ist der max der maximale Grenzwert, der festgelegt werden konnte??

InformationsquelleAutor chopss
13

Für mich, den folgenden Schritten gearbeitet:
1. Öffnen Sie die eclipse.ini Datei
2. Ändern
```
-Xms40m
-Xmx512m
```
  zu
```
-Xms512m
-Xmx1024m
```
3. Starten Sie Eclipse Erneut,
Siehe hier

die am meisten einfache Weise, dieses problem zu beheben. Vielen Dank 🙂
eclipse.ini-Datei in jdev?
Probleme ungelöst, auch wenn die Konfiguration geändert wurde.
problem noch nicht gelöst. Sie haben / kennen keine andere Weise?
Die OP hat nicht gefragt, eine Eclipse-Frage.

InformationsquelleAutor Sunil Kumar Sahoo
10

versuchen, diese

öffnen Sie die build.gradle Datei
```
  android {
        dexOptions {
           javaMaxHeapSize = "4g"
        }
   }
```
Funktioniert Super für den simulator. Irgendeine Idee, wie diese auf die realen Geräte? also ist das eine gute Idee oder ist es einfach nur maskieren das Problem? Danke.

InformationsquelleAutor alicanozkara

Folgende für mich gearbeitet. Fügen Sie einfach die folgenden 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"
    }
}

Ja, bei der Verwendung von Gradle 🙂
Wie konnte Sie auch denken, dies ist eine Lösung auf seine Frage, im Allgemeinen? Sie setzen Ihre heap-Größe zu 4g, die völlig willkürlich in einen gradle-Konfiguration für Android facepalm.

InformationsquelleAutor H.S.H

4

erhöhen javaMaxHeapsize in deinem build.gradle(Module:app) - Datei
```
dexOptions {
    javaMaxHeapSize "1g"
}
```
(Fügen Sie diese Zeile in gradle)
```
 dexOptions {
        javaMaxHeapSize "4g"
    }
```
nicht für mich arbeiten

InformationsquelleAutor saigopi
1

Neustart mein MacBook hat das Problem gelöst für mich.

InformationsquelleAutor Thomas

-1

Müssen Sie erhöhen Sie die Größe des Arbeitsspeichers in Jdeveloper gehen 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**
)

und

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

Diese Einstellungen sind nur speziell auf Ihre lokale IDE. Dies wird keine Arbeit für die Prod-Umgebung.

InformationsquelleAutor shashi

-1

Arbeite ich in Android Studio und begegnet dieser Fehler beim generieren eines signierten APK für die Freigabe.
Ich war in der Lage zu erstellen und testen Sie ein APK-debug-kein problem, aber sobald ich bauen wollte, ein release-APK, die den build-Prozess laufen würde für Minuten auf Ende und dann schließlich beendet mit dem "java-Fehlermeldung.lang.OutOfMemoryError: GC overhead limit exceeded". Ich erhöhte die heap-Größen für beide die VM und die Android-DEX-compiler, aber das problem blieb.
Endlich, nach vielen Stunden und Tassen des Kaffee-es stellte sich heraus, dass das problem war in meinem app-Ebene " zu bauen.gradle " - Datei - ich hatte die 'minifyEnabled' - parameter für den release build type set to 'false', folglich läuft Proguard Stoffe auf code, der bisher nicht durch die code-schrumpfen " - Prozess (siehe https://developer.android.com/studio/build/shrink-code.html).
Ich habe die 'minifyEnabled' parameter auf 'true' und dem release-build ausgeführt wie ein Traum 🙂

Kurz gesagt, ich musste meine app-Ebene " zu bauen.gradle " - Datei aus:
//...
```
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
    }
}

//...
```
zu
```
    //...

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

//...
```
InformationsquelleAutor Alex Ivan Howard
-1

Erhöhen heap-Größe in IntelliJ IDEA Folgen Sie den folgenden Anweisungen. Es funktionierte für mich.

Für Windows-Benutzer,

Gehen Sie zu dem Speicherort, in dem die IDE installiert ist, und suchen Sie nach folgenden.
```
idea64.exe.vmoptions
```
Bearbeiten die Datei und fügen Sie die folgende.
```
-Xms512m
-Xmx2024m
-XX:MaxPermSize=700m
-XX:ReservedCodeCacheSize=480m
```
Das ist es !!

InformationsquelleAutor Dulith De Costa
-2

Netbeans, kann es hilfreich sein design ein max-heap-Größe. Gehen Sie zu Laufen => Set Project Configuration => Anpassen. In der Laufen seiner knallte-up-Fenster, gehen Sie zu VM-Option, füllen Sie -Xms2048m -Xmx2048m. Es lösen könnte heap-Größe-problem.

InformationsquelleAutor Xiaogang

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.