Methode zum Finden eines Speicherlecks in großen Java-Heap-Dumps

Es ist fast unmöglich, ohne irgendein Verständnis von dem zugrunde liegenden code. Wenn Sie verstehen, die zugrunde liegenden code, dann kann man besser Sortieren, den Weizen von der Spreu von den Zillionen von bits von Informationen, die Sie bekommen in Ihre heap-dumps.

Können, können Sie auch nicht wissen, ob etwas ein Leck oder nicht, ohne zu wissen, warum das Klasse ist es in den ersten Platz.

Ich verbrachte die letzten paar Wochen tut genau dies, und ich habe ein iterativer Prozess.

Erste, ich fand die heap-Profiler im Grunde nutzlos. Sie können nicht analysieren, die enorme Haufen effizient.

Eher, verließ ich mich fast ausschließlich auf jmap Histogramme.

Ich kann mir vorstellen, du bist vertraut mit diesen, aber für diejenigen, die nicht:

jmap -histo:live <pid> > dump.out

erstellt ein Histogramm der live-heap. Kurz gesagt, es sagt Ihnen, die Namen der Klassen und wie viele Instanzen der einzelnen Klassen im heap.

Ich war dumping aus heap regelmäßig, alle 5 Minuten, 24h am Tag. Das mag wohl sein, zu präzise für Sie, aber das wesentliche ist die gleiche.

Lief ich mehrere verschiedene Analysen auf diesen Daten.

Schrieb ich ein Skript, um zwei Histogramme und dump, den Unterschied zwischen Ihnen. Also, wenn java.lang.String 10 war in der ersten dump, und 15 in der zweiten, mein script würde ausspucken "5 java.lang.String" sage mir, es ging bis um 5. Wenn es war untergegangen, die Zahl wäre negativ.

Ich würde einige dieser Unterschiede, Streifen Sie heraus alle Klassen, ging von Lauf zu Lauf, und nehmen Sie eine union mit dem Ergebnis. Am Ende, würde ich eine Liste der Klassen, die kontinuierlich wuchs über einen bestimmten Zeitraum. Offensichtlich sind diese Hauptkandidaten für undichte Klassen.

Jedoch, einige Klassen haben einige erhalten, während andere GC würde. Diese Klassen könnten leicht rauf und runter in der Gesamtwertung, aber immer noch undicht. So, könnten Sie fallen aus der "immer steigende" - Kategorie von Klassen.

Diese zu finden, habe ich konvertiert die Daten in einer Zeit-Serie und lud Sie in eine Datenbank, Postgres-spezifisch. Postgres ist praktisch, denn es bietet statistische Aggregatfunktionenso können Sie tun, einfache linear regression analysis auf die Daten, und finden Sie Klassen, die den trend, auch wenn Sie nicht immer an der Spitze der charts. Ich benutzte die regr_slope Funktion, auf der Suche nach Klassen mit einer positiven Steigung.

Ich fand diesen Prozess sehr erfolgreich und sehr effizient. Die Histogramme Dateien sind nicht wahnsinnig groß, und es war einfach laden Sie Sie von den Gastgebern. Sie waren nicht super teuer ist auf die Produktion system (zwingen Sie eine große GC, und blockieren die VM ein bisschen). Ich war dieses laufen auf einem system mit einem 2G-Java-heap.

Nun, all dies tun können, ist identifizieren Sie potenziell undichte Klassen.

Dies ist, wo das Verständnis, wie die Klassen verwendet werden, und ob Sie sollte oder sollte nicht Ihre kommt ins Spiel.

Zum Beispiel, können Sie feststellen, dass Sie eine Menge von Anzeigen.Eintrag Klassen, oder einige andere system-Klasse.

Es sei denn, du bist einfach Zwischenspeichern String, Tatsache ist, dass diese system-Klassen, während vielleicht die "Täter", nicht das "problem". Wenn Sie die Zwischenspeicherung einige application-Klasse, DIE Klasse ist ein besserer Indikator, wo dein problem liegt. Wenn Sie nicht cache-com.app.yourbean, dann wirst du nicht die zugehörige Karte.Eintrag gebunden.

Haben Sie einige Klassen, können Sie beginnen, durchsucht die code-Basis suchen, Instanzen und Referenzen. Da haben Sie Ihre eigenen ORM-layer (für gut oder schlecht), kann man wenigstens leicht, den Quellcode anzusehen. Wenn Sie ORM ist caching-Zeug, es ist wahrscheinlich ein caching-ORM-Klassen Verpackung Ihrer Anwendung Klassen.

Schließlich noch eine weitere Sache, die Sie tun können, ist, sobald Sie wissen, die Klassen, können Sie beginnen, eine lokale Instanz des Servers mit einem viel kleineren heap und kleinere dataset, und mit einer der die Profiler dagegen.

In diesem Fall können Sie tun, unit test, der betrifft nur 1 (oder wenige) der Dinge, die Sie denken können lecken. Sie könnten zum Beispiel starten Sie den server, führen Sie ein Histogramm, eine einzelne Aktion durchzuführen, und führen Sie das Histogramm wieder. Sie leckt Klasse sollte um 1 erhöht (oder was auch immer Ihre Einheit der Arbeit ist).

Profiler kann in der Lage sein, um Ihnen zu helfen verfolgen Sie den Besitzer, "jetzt durchgesickert" sind Klasse.

Aber, im Ende, sind Sie gehen zu müssen, haben ein gewisses Verständnis für Ihre code-Basis, um besser zu verstehen, was ist ein Leck, und was nicht, und warum ein Objekt in dem heap überhaupt, noch viel weniger, warum kann es sein, beibehalten wird wie ein Leck in Ihrem heap.

InformationsquelleAutor der Antwort Will Hartung

Diese Antwort baut auf @-Hartung. Ich bewarb mich um gleiche Verfahren zum diagnostizieren einer meiner memory-leaks und dachte, dass das teilen der details sparen würde, anderen Menschen Zeit.

Die Idee ist, postgres 'plot' Zeit vs. Speicher-Auslastung der einzelnen Klasse, zeichnen Sie eine Linie, fasst das Wachstum und die Objekte identifizieren, die am schnellsten wachsen:

    ^
    |
s   |  Legend:
i   |  *  - data point
z   |  -- - trend
e   |
(   |
b   |                 *
y   |                     --
t   |                  --
e   |             * --    *
s   |           --
)   |       *--      *
    |     --    *
    |  -- *
   --------------------------------------->
                      time

Konvertieren heap dumps (brauchen mehrere) in einem format, das bequem ist für die Nutzung von postgres aus der heap-dump-format:

 num     #instances         #bytes  class name 
----------------------------------------------
   1:       4632416      392305928  [C
   2:       6509258      208296256  java.util.HashMap$Node
   3:       4615599      110774376  java.lang.String
   5:         16856       68812488  [B
   6:        278914       67329632  [Ljava.util.HashMap$Node;
   7:       1297968       62302464  
...

In eine csv-Datei mit den datetime-jeder heap-dump:

2016.09.20 17:33:40,[C,4632416,392305928
2016.09.20 17:33:40,java.util.HashMap$Node,6509258,208296256
2016.09.20 17:33:40,java.lang.String,4615599,110774376
2016.09.20 17:33:40,[B,16856,68812488
...

Verwenden Sie dieses Skript:

# Example invocation: convert.heap.hist.to.csv.pl -f heap.2016.09.20.17.33.40.txt -dt "2016.09.20 17:33:40"  >> heap.csv 

 my $file;
 my $dt;
 GetOptions (
     "f=s" => \$file,
     "dt=s" => \$dt
 ) or usage("Error in command line arguments");
 open my $fh, '<', $file or die $!;

my $last=0;
my $lastRotation=0;
 while(not eof($fh)) {
     my $line = <$fh>;
     $line =~ s/\R//g; #remove newlines
     #    1:       4442084      369475664  [C
     my ($instances,$size,$class) = ($line =~ /^\s*\d+:\s+(\d+)\s+(\d+)\s+([\$\[\w\.]+)\s*$/) ;
     if($instances) {
         print "$dt,$class,$instances,$size\n";
     }
 }

 close($fh);

Erstellen Sie eine Tabelle, um die Daten in

CREATE TABLE heap_histogram (
    histwhen timestamp without time zone NOT NULL,
    class character varying NOT NULL,
    instances integer NOT NULL,
    bytes integer NOT NULL
);

Kopieren Sie die Daten in die neue Tabelle

\COPY heap_histogram FROM 'heap.csv'  WITH DELIMITER ',' CSV ;

Laufen die slop-Abfrage gegen die Dateigröße (Anzahl der bytes) Abfrage:

SELECT class, REGR_SLOPE(bytes,extract(epoch from histwhen)) as slope
    FROM public.heap_histogram
    GROUP BY class
    HAVING REGR_SLOPE(bytes,extract(epoch from histwhen)) > 0
    ORDER BY slope DESC
    ;

Interpretieren Sie die Ergebnisse:

         class             |        slope         
---------------------------+----------------------
 java.util.ArrayList       |     71.7993806279174
 java.util.HashMap         |     49.0324576155785
 java.lang.String          |     31.7770770326123
 joe.schmoe.BusinessObject |     23.2036817108056
 java.lang.ThreadLocal     |     20.9013528767851

Den Hang hinzugefügten bytes pro Sekunde (da die Einheit der Epoche wird in Sekunden angegeben). Wenn Sie mit Instanzen statt Größe, dann ist die Anzahl der Instanzen Hinzugefügt pro Sekunde.

Meine die Zeilen von code erstellen dieser joe.schmoe.BusinessObject war verantwortlich für das Speicher-Leck. Es war Sie das Objekt erstellen, anfügen an ein array ohne zu prüfen, ob es das schon gibt. Die anderen Objekte wurden auch erstellt, zusammen mit den BusinessObject in der Nähe der undichten code.

InformationsquelleAutor der Antwort joseph

Hatte ich Erfolg mit IBM Heap Analyzer. Es bietet verschiedene Ansichten des heap, einschließlich der größte drop-off in die Größe des Objekts, die am häufigsten vorkommenden Objekte, und die Objekte nach Größe sortiert.

InformationsquelleAutor der Antwort Drew Johnson

Ich verwendet habe,jhatdas ist ein bisschen hart, aber es hängt von der Art des Rahmens, die Sie hatten.

InformationsquelleAutor der Antwort LB40