Outil en ligne de commande pour trouver la taille Java et la mémoire utilisée (Linux)?

chaque processus Java a un pid , que vous devez d'abord trouver avec la commande jps .

une fois que vous avez le pid, vous pouvez utiliser jstat -gc [insert-pid-here] pour trouver des statistiques sur le comportement du tas de déchets collectés.

• jstat -gccapacity [insert-pid-here] présentera des informations sur la génération de mémoire et les capacités spatiales.

• jstat -gcutil [insert-pid-here] présentera le utilisation de chaque génération en pourcentage de sa capacité. Très utile pour avoir une en un coup d'œil vue de l'utilisation.

voir jstat docs sur le site D'Oracle.

jvmtop est un outil en ligne de commande qui fournit une vue en direct à plusieurs paramètres, y compris tas.

exemple de sortie du mode Aperçu 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

cette commande affiche les tailles de tas configurées en octets.

java -XX:+PrintFlagsFinal -version | grep HeapSize

il fonctionne sur Amazon AMI sur EC2 aussi.

Essayez cela, il a travaillé dans Ubuntu et RedHat:

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

Pour Windows:

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

Pour Mac

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

La sortie de toutes ces commandes ressemble à la sortie ci-dessous:

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)

pour trouver la taille en MB, divisez la valeur par (1024*1024).

sans utiliser JMX, qui est ce que la plupart des outils utilisent, tout ce que vous pouvez faire est d'utiliser

jps -lvm

et déduire que les paramètres seront à partir des options de ligne de commande.

vous ne pouvez pas obtenir d'informations dynamiques sans JMX par défaut, mais vous pouvez écrire votre propre service pour le faire.

BTW: je préfère utiliser VisualVM plutôt que JConsole.

il y a un outil en ligne de commande avec un aspect visuel - jvm-mon . C'est un outil de surveillance JVM pour la ligne de commande qui désaplie:

• l'utilisation du tas, de la taille et max
• procédés jvm
• utilisation cpu et GC
• TOP threads

les mesures et les graphiques mettent à jour pendant que l'outil est ouvert.

échantillon:

Tard dans la partie, mais une solution très simple consiste à utiliser l'jpsstat.sh script. Il fournit un live simple mémoire courante , mémoire max et utilisation cpu détails.

• Goto projet GitHub et télécharger le jpsstat.sh file
• clic droit sur jpsstat.sh et goto autorisations onglet et le rendre exécutable
• exécutez maintenant le script en utilisant la commande suivante . /jpsstat.sh

Voici la sortie d'échantillon de 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

en termes de taille Java heap, sous Linux, vous pouvez utiliser

ps aux | grep java

ou

ps -ef | grep java

et recherchez-Xms, -Xmx pour connaître la taille initiale et maximale de tas spécifiée.

cependant, si-Xms ou-Xmx est absent pour le processus Java qui vous intéresse, cela signifie que votre processus Java utilise les tailles par défaut. Vous pouvez utiliser la commande suivante pour trouver les tailles par défaut.

java -XX:+PrintFlagsFinal -version | grep HeapSize

ou une jvm particulière, par exemple,

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

et chercher InitialHeapSize et MaxHeapSize, qui est en octets.

obtenez D'abord l'identifiant du processus, le premier numéro du processus indiqué, à partir de l'un des suivants: (ou utilisez simplement ps aux | grep java , si vous préférez que)

jps -lvm

alors utilisez le numéro de processus ici:

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

Toute approche devrait vous donner à peu près le même nombre. C'est toujours une bonne idée d'allouer le tas en utilisant -X..m -X..x pour toutes les générations. Vous pouvez alors garantir et aussi faire ps pour voir quels paramètres ont été passés et donc utilisés.

pour les utilisations réelles de la mémoire, vous pouvez grossièrement comparer VIRT (alloué et partagé) et RES (réel utilisé) comparer avec les valeurs jstat ainsi:

pour Java 8, voir jstat pour ces valeurs signifie réellement. En supposant que vous exécutiez une classe simple sans traitement mmap ou fichier.

$ 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

(plus ou moins proche de la mémoire virtuelle)

Max (Min, Used): 215040 + 512 + 512 + 67072 + 430080 + 39680 + 4864 = ~ 1GB

(à peu près proche de la mémoire RÉS)

"Ne pas me citer sur ce" mais VIRT mem est à peu près près ou plus de mémoire Max allouées, mais aussi longtemps que mémoire est disponible/disponibles dans la mémoire physique, la JVM ne jetez pas souvenir d'exception. En fait, la mémoire max n'est même pas vérifiée par rapport à la mémoire physique au démarrage de JVM, même avec swap off sur OS. Une meilleure explication de ce que la mémoire virtuelle réellement utilisé par un processus Java est discuté ici .

si vous utilisez jrockit, essayez l'outil en ligne de commande jrcmd. Par exemple:

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

pour plus de commandes, comme heap_diagnostics, utilisez" jrcmd help " pour les lister.

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

L'utilisation de la commande top est le moyen le plus simple de vérifier l'utilisation du programme en mémoire. RES colonne montre la mémoire physique réelle qui est occupée par un processus.

pour mon cas, j'ai eu un fichier 10g lu en java et à chaque fois j'ai eu une exception outOfMemory. Cela s'est produit lorsque la valeur dans la colonne RES a atteint la valeur définie dans l'option -Xmx . Puis en augmentant la mémoire en utilisant l'option -Xmx tout s'est bien passé.

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

exemple D'O / P de la commande ci-dessus

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

obtenez plus de détails à ce sujet à http://docs.oracle.com/javase/1.5.0/docs/tooldocs/share/jstat.html