wake-up-neo.com

Befehlszeilentool zum Ermitteln von Java Heap-Größe und verwendetem Speicher (Linux)?

Gibt es ein Befehlszeilentool (Linux) zum Überprüfen der Heap-Größe (und des verwendeten Speichers) einer Java -Anwendung?

Ich habe jmap ausprobiert Aber es gibt Infos. über interne Speicherbereiche wie Eden/PermGen usw., was mir nicht nützlich ist.

Ich suche etwas wie:
Maximaler Arbeitsspeicher: 1 GB
Mindestspeicher: 256 MB
Heapspeicher: 700 MB
Verwendeter Speicher: 460 MB

Das ist alles. Ich weiß, dass ich dies in JConsole usw. sehen kann, aber ich benötige ein Befehlszeilentool (kann JMX usw. nicht aktivieren).

Ein solches Werkzeug/Befehl?

javalinuxmemoryheap
141
Jasper

Jeder Java Prozess hat einen pid, den Sie zuerst mit dem jps Befehl finden müssen.

Sobald Sie die PID haben, können Sie jstat -gc [insert-pid-here] verwenden, um Statistiken über das Verhalten des Heaps mit gesammelten Speicherbereinigungen zu erhalten.

  • jstat -gccapacity [insert-pid-here] zeigt Informationen zur Speicherpoolgenerierung und zu Speicherplatzkapazitäten an.

  • jstat -gcutil [insert-pid-here] zeigt die Auslastung jeder Generation als Prozentsatz ihrer Kapazität an. Nützlich, um einen Überblick über die Verwendung zu erhalten.

Siehe jstat docs auf der Oracle-Site.

134
farmer1992

jvmtop ist ein Befehlszeilentool, das eine Live-Ansicht mit mehreren Metriken, einschließlich Heap, bietet.

Beispielausgabe des Übersichtsmodus VM:

 JvmTop 0.3 alpha (expect bugs)  AMD64  8 cpus, Linux 2.6.32-27, load avg 0.12
 http://code.google.com/p/jvmtop

  PID MAIN-CLASS      HPCUR HPMAX NHCUR NHMAX    CPU     GC    VM USERNAME   #T DL
 3370 rapperSimpleApp  165m  455m  109m  176m  0.12%  0.00% S6U37 web        21
11272 ver.resin.Resin [ERROR: Could not attach to VM]
27338 WatchdogManager   11m   28m   23m  130m  0.00%  0.00% S6U37 web        31
19187 m.jvmtop.JvmTop   20m 3544m   13m  130m  0.93%  0.47% S6U37 web        20
16733 artup.Bootstrap  159m  455m  166m  304m  0.12%  0.00% S6U37 web        46
60
MRalwasser

Dieser Befehl zeigt die konfigurierten Heap-Größen in Bytes an.

Java -XX:+PrintFlagsFinal -version | grep HeapSize

Es funktioniert auch mit Amazon AMI auf EC2.

52
Atma

Versuchen Sie dies, es funktionierte in Ubuntu und RedHat:

Java -XX:+PrintFlagsFinal -version | grep -iE 'HeapSize|PermSize|ThreadStackSize'

Für Windows:

Java -XX:+PrintFlagsFinal -version | findstr /i "HeapSize PermSize ThreadStackSize"

Für Mac

Java -XX:+PrintFlagsFinal -version | grep -iE 'heapsize|permsize|threadstacksize'

Die Ausgabe all dieser Befehle ähnelt der folgenden Ausgabe:

uintx InitialHeapSize                          := 20655360        {product}
uintx MaxHeapSize                              := 331350016       {product}
uintx PermSize                                  = 21757952        {pd product}
uintx MaxPermSize                               = 85983232        {pd product}
intx ThreadStackSize                           = 1024            {pd product}
Java version "1.7.0_05"
Java(TM) SE Runtime Environment (build 1.7.0_05-b05)
Java HotSpot(TM) 64-Bit Server VM (build 23.1-b03, mixed mode)

Teilen Sie den Wert durch (1024 * 1024), um die Größe in MB zu ermitteln.

33
padippist

Ohne JMX, wie es die meisten Tools verwenden, können Sie nur JMX verwenden

jps -lvm

und schließen Sie daraus, dass die Einstellungen über die Befehlszeilenoptionen vorgenommen werden.

Ohne JMX können Sie standardmäßig keine dynamischen Informationen abrufen, Sie können jedoch einen eigenen Dienst schreiben, um dies zu tun.

Übrigens: Ich benutze lieber VisualVM als JConsole.

24
Peter Lawrey

Es gibt ein Kommandozeilen-Tool mit einem visuellen Aspekt - jvm-mon . Es ist ein JVM-Überwachungstool für die Befehlszeile, das nicht funktioniert:

  • heap-Nutzung, Größe und max
  • jVM-Prozesse
  • cPU- und GC-Nutzung
  • top-Themen

Die Metriken und Diagramme werden aktualisiert, während das Tool geöffnet ist.

Stichprobe: jvm-mon

18
Andrejs

Spät auf der Party, aber eine sehr einfache Lösung ist die Verwendung des Skripts jpsstat.sh. Es bietet einen einfachen Live aktuellen Speicher , maximalen Speicher und CPU-Nutzung Details.

  • Gehe zu GitHub-Projekt und lade die Datei jpsstat.sh herunter
  • Rechtsklicke auf jpsstat.sh und gehe zu Berechtigungen und mache es ausführbar
  • Führen Sie nun das Skript mit folgendem Befehl aus ./ jpsstat.sh

Hier ist die Beispielausgabe von script -

=====  ======  =======  =======  =====
 PID    Name   CurHeap  MaxHeap  %_CPU
=====  ======  =======  =======  =====
2777   Test3      1.26     1.26    5.8
2582   Test1      2.52     2.52    8.3
2562   Test2      2.52     2.52    6.4
7
amarjeetAnand

Jeder Ansatz sollte Ihnen ungefähr die gleiche Zahl geben. Es ist immer eine gute Idee, den Heap mit -X..m-X..x für alle Generationen zuzuweisen. Sie können dann ps garantieren und auch tun, um zu sehen, welche Parameter übergeben wurden und daher verwendet werden.

Für die tatsächliche Speichernutzung können Sie VIRT (zugewiesen und gemeinsam genutzt) und RES (tatsächlich verwendet) grob mit den jstat-Werten vergleichen:

Für Java 8 siehe jstat für diese Werte bedeuten tatsächlich. Angenommen, Sie führen eine einfache Klasse ohne MMAP- oder Dateiverarbeitung aus.

$ jstat -gccapacity 32277
 NGCMN    NGCMX     NGC     S0C   S1C       EC      OGCMN      OGCMX       OGC         OC       MCMN     MCMX      MC     CCSMN    CCSMX     CCSC    YGC    FGC
215040.0 3433472.0  73728.0  512.0  512.0  67072.0   430080.0  6867968.0   392704.0   392704.0      0.0 1083392.0  39680.0      0.0 1048576.0   4864.0   7225     2

$ jstat -gcutil 32277
  S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT
  6.25   0.00   7.96  18.21  98.01  95.29   7228   30.859     2    0.173   31.032

Max :

     NGCMX + S0C + S1C + EC    + OGCMX   + MCMX    + CCSMX
   3433472 + 512 + 512 + 67072 + 6867968 + 1083392 + 1048576 = 12 GB

(ungefähr in der Nähe und unterhalb des VIRT-Speichers)

Max (Min, Used): 

215040 + 512 + 512 + 67072 + 430080  + 39680    +  4864  = ~ 1GB

(ungefähr in der Nähe des RES-Speichers)

"Zitiere mich nicht dazu", aber VIRT mem ist ungefähr gleich oder größer als der maximal zugewiesene Speicher, aber solange Speicher verwendet wird ist frei/JVM ist im physischen Speicher verfügbar und löst keine Speicherausnahme aus. Tatsächlich wird der maximale Arbeitsspeicher beim Starten von JVM nicht einmal mit dem physischen Arbeitsspeicher verglichen, selbst wenn das Betriebssystem zum Auslagern ausgeschaltet ist. Eine bessere Erklärung, welcher virtuelle Speicher von einem Java -Prozess tatsächlich verwendet wird, wird hier erläutert .

5
kisna

Ab Java8 können Sie den folgenden Befehl verwenden:

jcmd Java_PROCESS_ID GC.heap_info

Sie können sich auf die Summe, den Gesamt- und den belegten Speicher der Ausgabe beziehen.

Sample Command And Output: jcmd 9758 GC.heap_info

PSYoungGen  total 1579520K, used 487543K [0x0000000751d80000, 0x00000007c0000000, 0x00000007c0000000)
  eden space 1354240K, 36% used [0x0000000751d80000,0x000000076f99dc40,0x00000007a4800000)
  from space 225280K, 0% used [0x00000007b2400000,0x00000007b2400000,0x00000007c0000000)
  to   space 225280K, 0% used [0x00000007a4800000,0x00000007a4800000,0x00000007b2400000)
ParOldGen       total 3610112K, used 0K [0x0000000675800000, 0x0000000751d80000, 0x0000000751d80000)
  object space 3610112K, 0% used [0x0000000675800000,0x0000000675800000,0x0000000751d80000)
Metaspace       used 16292K, capacity 16582K, committed 16896K, reserved 1064960K
  class space    used 1823K, capacity 1936K, committed 2048K, reserved 1048576K

Weitere Informationen zum Befehl jcmd finden Sie unter folgendem Link: https://docs.Oracle.com/javase/8/docs/technotes/guides/troubleshoot/tooldescr006.html

3
vaibhav gupta

Ermitteln Sie zunächst die Prozess-ID, die erste Nummer aus dem aufgelisteten Prozess, aus einer der folgenden Angaben: (oder verwenden Sie einfach ps aux | grep Java, wenn Sie dies vorziehen.)

jps -lvm

Dann verwenden Sie hier die Prozess-ID:

jmap -heap $MY_PID 2>/dev/null | sed -ne '/Heap Configuration/,$p';
jmap -permstat $MY_PID
2
sjas

Die Verwendung des Befehls top ist die einfachste Möglichkeit, die Speichernutzung des Programms zu überprüfen. Die Spalte RES zeigt den realen physischen Speicher, der von einem Prozess belegt wird.

In meinem Fall hatte ich eine 10g-Datei in Java eingelesen und jedes Mal, wenn ich die Ausnahme outOfMemory bekam. Dies geschah, als der Wert in der Spalte RES den in der Option -Xmx festgelegten Wert erreichte. Durch Erhöhen des Speichers mit der Option -Xmx ging alles in Ordnung.

1
M. Mashaye
jstat -gccapacity javapid  (ex. stat -gccapacity 28745)
jstat -gccapacity javapid gaps frames (ex.  stat -gccapacity 28745 550 10 )

Beispiel-O/P des obigen Befehls

NGCMN    NGCMX     NGC     S0C  
87040.0 1397760.0 1327616.0 107520.0 

NGCMN   Minimum new generation capacity (KB).
NGCMX   Maximum new generation capacity (KB).
NGC Current new generation capacity (KB).

Weitere Informationen hierzu finden Sie unter http://docs.Oracle.com/javase/1.5.0/docs/tooldocs/share/jstat.html

1
Pravin

In Bezug auf die Java Heap-Größe können Sie unter Linux verwenden

ps aux | grep Java

oder

ps -ef | grep Java

und suchen Sie nach -Xms, -Xmx, um die angegebene anfängliche und maximale Heap-Größe zu ermitteln.

Wenn jedoch -Xms oder -Xmx für den Java -Prozess, an dem Sie interessiert sind, nicht vorhanden ist, bedeutet dies, dass Ihr Java -Prozess die Standard-Heap-Größen verwendet. Mit dem folgenden Befehl können Sie die Standardgrößen ermitteln.

Java -XX:+PrintFlagsFinal -version | grep HeapSize

oder eine bestimmte jvm, zum Beispiel,

/path/to/jdk1.8.0_102/bin/Java -XX:+PrintFlagsFinal -version | grep HeapSize

und suchen Sie nach InitialHeapSize und MaxHeapSize, die in Bytes ist.

1
Yuci

Wenn Sie jrockit verwenden, versuchen Sie es mit dem Befehlszeilentool jrcmd. Zum Beispiel:

$ jrcmd 5127 print_memusage
5127:
Total mapped                  1074596KB           (reserved=3728KB)
-              Java heap       786432KB           (reserved=0KB)
-              GC tables        26316KB          
-          Thread stacks        13452KB           (#threads=34)
-          Compiled code         9856KB           (used=9761KB)
-               Internal          840KB          
-                     OS        15036KB          
-                  Other       146632KB          
-        Java class data        75008KB           (malloced=74861KB #103221 in 18709 classes)
- Native memory tracking         1024KB           (malloced=102KB #8)

Verwenden Sie für weitere Befehle wie heap_diagnostics "jrcmd help", um sie aufzulisten.

https://blogs.Oracle.com/jrockit/entry/why_is_my_jvm_process_larger_t

1
guest

Bisher gibt es kein solches Tool, um den Heapspeicher in dem von Ihnen gewünschten Format zu drucken. Die einzige und einzige Möglichkeit zum Drucken ist das Schreiben eines Java Programm mit Hilfe von Runtime Class ,

public class TestMemory {

public static void main(String [] args) {

    int MB = 1024*1024;

    //Getting the runtime reference from system
    Runtime runtime = Runtime.getRuntime();

    //Print used memory
    System.out.println("Used Memory:" 
        + (runtime.totalMemory() - runtime.freeMemory()) / MB);

    //Print free memory
    System.out.println("Free Memory:" 
        + runtime.freeMemory() / mb);

    //Print total available memory
    System.out.println("Total Memory:" + runtime.totalMemory() / MB);

    //Print Maximum available memory
    System.out.println("Max Memory:" + runtime.maxMemory() / MB);
}

}

referenz: https://viralpatel.net/blogs/getting-jvm-heap-size-used-memory-total-memory-using-Java-runtime/

0
Gowtham Prasath