Strumento da riga di comando per trovare la dimensione dell'heap Java e la memoria utilizzata (Linux)?

Esiste uno strumento da riga di comando (Linux) per controllare la dimensione dell'heap (e la memoria utilizzata) di un'applicazione Java?

Ho provato tramite jmap. Ma dà informazioni. su aree di memoria interna come Eden / PermGen ecc., che non mi è utile.

Sto cercando qualcosa come:

• Memoria massima: 1 GB
• Memoria minima: 256 MB
• Memoria heap: 700 MB
• Memoria utilizzata: 460 MB

È tutto. So di poterlo vedere in JConsole ecc., Ma ho bisogno di uno strumento da riga di comando (non posso abilitare JMX ecc.)

Conosci qualche strumento / comando del genere?

Ogni processo Java ha un pid, che devi prima trovare con il jpscomando.

Una volta ottenuto il pid, è possibile utilizzare jstat -gc [insert-pid-here]per trovare statistiche sul comportamento dell'heap raccolto immondizia.

• jstat -gccapacity [insert-pid-here] presenterà informazioni sulla generazione del pool di memoria e le capacità di spazio.

• jstat -gcutil [insert-pid-here]presenterà l'utilizzo di ogni generazione come percentuale della sua capacità. Utile per avere una visione d'insieme dell'uso.

Consulta i documenti jstat sul sito di Oracle.

jvmtop è uno strumento da riga di comando che fornisce una vista dal vivo su diverse metriche, incluso heap.

Esempio di output della modalità panoramica 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

Questo comando mostra le dimensioni dell'heap configurate in byte.

java -XX:+PrintFlagsFinal -version | grep HeapSize

Funziona su Amazon AMI anche su EC2.

Prova questo ha funzionato in Ubuntu e RedHat:

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

Per Windows:

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

Per Mac

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

L'output di tutti questi comandi è simile all'output seguente:

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)

Per trovare la dimensione in MB, dividere il valore con (1024 * 1024).

Senza usare JMX, che è quello che la maggior parte degli strumenti usa, tutto ciò che puoi fare è usare

jps -lvm

e dedurre che le impostazioni saranno dalle opzioni della riga di comando.

Non puoi ottenere informazioni dinamiche senza JMX per impostazione predefinita, ma puoi scrivere il tuo servizio per farlo.

A proposito: preferisco usare VisualVM piuttosto che JConsole.

Esiste uno strumento da riga di comando con un aspetto visivo: jvm-mon . È uno strumento di monitoraggio JVM per la riga di comando che disaplys:

• heap utilizzo, dimensioni e max
• processi jvm
• utilizzo di cpu e GC
• discussioni in alto

Le metriche e i grafici si aggiornano mentre lo strumento è aperto.

Campione:

In ritardo alla festa, ma una soluzione molto semplice è usare lo script jpsstat.sh. Fornisce una semplice memoria corrente attiva , memoria massima e dettagli sull'uso della CPU .

• Vai al progetto GitHub e scarica il file jpsstat.sh
• Fare clic con il tasto destro su jpsstat.sh e andare alla scheda permessi e renderlo eseguibile
• Ora esegui lo script usando il seguente comando ./jpsstat.sh

Ecco l'output di esempio dello 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

Nel mio caso avevo bisogno di controllare le bandiere all'interno di un contenitore docker che non aveva la maggior parte delle utilità di base (ps, pstree ...)

Usando jpsho ottenuto il PID della JVM in esecuzione (nel mio caso 1) e poi con jcmd 1 VM.flagsho ottenuto i flag dalla JVM in esecuzione.

Dipende da quali comandi hai a disposizione, ma questo potrebbe aiutare qualcuno. :)

Da Java8 e versioni successive , è possibile utilizzare il comando seguente:

jcmd JAVA_PROCESS_IDGC.heap_info

È possibile fare riferimento alla somma della memoria totale e utilizzata dall'output.

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

Per maggiori dettagli sul comando jcmd, visitare il link: https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/tooldescr006.html

Qualsiasi approccio dovrebbe darti approssimativamente lo stesso numero. È sempre una buona idea assegnare l'heap utilizzando -X..m -X..xper tutte le generazioni. Puoi quindi garantire e fare anche ps per vedere quali parametri sono stati passati e quindi utilizzati.

Per gli utilizzi effettivi della memoria, è possibile confrontare approssimativamente il confronto VIRT (allocato e condiviso) e RES (effettivamente utilizzato) con i valori jstat:

Per Java 8, vedere jstat per questi valori in realtà significano. Supponendo di eseguire una classe semplice senza mmap o elaborazione di file.

$ 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

(approssimativamente vicino e sotto alla memoria VIRT)

Max (Min, usato):

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

(approssimativamente vicino alla memoria RES)

"Non citarmi su questo" ma VIRT mem è approssimativamente vicino o superiore alla memoria Max allocata ma fintanto che la memoria utilizzata è libera / disponibile nella memoria fisica, JVM non genera eccezioni di memoria. In effetti, la memoria massima non viene nemmeno verificata rispetto alla memoria fisica all'avvio di JVM anche con swap disattivato sul sistema operativo. Una spiegazione migliore di quale memoria virtuale è realmente utilizzata da un processo Java è discussa qui .

Per prima cosa ottieni l'id del processo, il primo numero dal processo elencato, da uno dei seguenti: (o usa semplicemente ps aux | grep java, se lo preferisci)

jps -lvm

Quindi utilizzare l'ID processo qui:

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

L'uso del topcomando è il modo più semplice per controllare l'utilizzo della memoria del programma. REScolonna mostra la memoria fisica reale occupata da un processo.

Per il mio caso, avevo un file da 10 g letto in java e ogni volta che uscivo dall'eccezione di Memoria. Ciò è accaduto quando il valore nella REScolonna ha raggiunto il valore impostato -Xmxnell'opzione. Quindi aumentando la memoria usando l' -Xmxopzione tutto è andato bene.

In termini di dimensioni dell'heap Java, in Linux è possibile utilizzare

ps aux | grep java

o

ps -ef | grep java

e cerca -Xms, -Xmx per scoprire la dimensione heap iniziale e massima specificata.

Tuttavia, se -Xms o -Xmx è assente per il processo Java che ti interessa, significa che il tuo processo Java utilizza le dimensioni heap predefinite. È possibile utilizzare il comando seguente per scoprire le dimensioni predefinite.

java -XX:+PrintFlagsFinal -version | grep HeapSize

o un particolare jvm, ad esempio,

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

e cerca InitialHeapSize e MaxHeapSize, che è in byte.

Se si utilizza jrockit, provare lo strumento da riga di comando jrcmd. Per esempio:

$ 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)

Per altri comandi, come heap_diagnostics, usa "jrcmd help" per elencarli.

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

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

Esempio O / P del comando sopra

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).

Maggiori dettagli a riguardo su http://docs.oracle.com/javase/1.5.0/docs/tooldocs/share/jstat.html

Finora non esiste uno strumento simile per stampare la memoria heap nel formato richiesto. L'unico e unico modo per stampare è scrivere un programma java con l'aiuto di 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);
}

}

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

Trova dall'alto l'id del processo del tuo processo webapp / java. Utilizzare jmap heap per ottenere l'allocazione dell'heap. Ho provato questo su AWS-Ec2 per beanstalk elastico

Nell'immagine puoi vedere un heap massimo di 3 GB per l'applicazione