Outil de ligne de commande pour trouver la Taille du tas Java et la mémoire utilisée (Linux)?

Existe-t-il un outil de ligne de commande (Linux) pour vérifier la Taille du tas (et la mémoire utilisée) d'une application Java?

J'ai essayé jmap. Mais ça donne des infos. à propos des zones de mémoire interne comme Eden / PermGen, etc. qui n'est pas utile pour moi.

Je cherche quelque chose comme:
Max Mémoire: 1 Gb
Mémoire minimale: 256 Mo
Mémoire de tas: 700 Mo
Mémoire utilisée: 460 Mo

C'est tout. Je sais que je peux voir cela dans JConsole etc. mais j'ai besoin d'un outil de ligne de commande (pas de activer JMX etc.)

Un tel outil/commande?

Author: Jasper, 2012-10-09
Source

13 answers

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 du comportement du tas de déchets collectés.

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

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

Voir jstat docs sur Oracle du site.

 113
Author: farmer1992, 2017-02-01 20:03:34

Jvmtop est un outil en ligne de commande qui fournit une vue en direct à plusieurs métriques, y compris le tas.

Exemple de sortie du mode aperçu de la machine virtuelle: 

 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
 58
Author: MRalwasser, 2015-11-20 18:29:21

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

java -XX:+PrintFlagsFinal -version | grep HeapSize

Cela fonctionne également sur Amazon AMI sur EC2.

 43
Author: Atma, 2017-12-13 22:44:18

Essayez cela cela a fonctionné 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 Mo, divisez la valeur avec (1024*1024).

 26
Author: padippist, 2017-12-13 22:45:59

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

jps -lvm

Et en 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 ce faire.

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

 20
Author: Peter Lawrey, 2012-10-09 10:09:26

Il existe 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 disaplys:

  • utilisation du tas, taille et max
  • processus jvm
  • utilisation du processeur et du GC
  • fils supérieurs

Les métriques et les graphiques sont mis à jour lorsque l'outil est ouvert.

Exemple: jvm-lun.

 11
Author: Andrejs, 2017-02-17 16:44:24

En retard à la fête, mais une solution très simple consiste à utiliser le jpsstat.sh script. Il fournit une simple mémoire active , max mémoire et cpu utiliser détails.

    Le projet GitHub a été créé en 1999 et a été développé en 1999. jpsstat.sh fichier
  • cliquez-Droit sur jpsstat.sh et goto autorisations onglet et de le rendre exécutable
  • Exécutez maintenant le script en utilisant la commande suivante ./jpsstat.sh

Voici l'exemple de sortie du 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
 5
Author: amarjeetAnand, 2018-06-10 05:53:34

En termes de taille de tas Java, 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 du 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 de tas par défaut. Vous pouvez utiliser la commande suivante pour connaître 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 recherchez InitialHeapSize et MaxHeapSize, qui est en octets.

 2
Author: Yuci, 2016-12-08 11:40:26

Obtenez d'abord l'id du processus, le premier numéro du processus répertorié, à partir de l'un des éléments suivants: (ou utilisez simplement ps aux | grep java, si vous préférez cela) 

jps -lvm

Puis utilisez l'ID du processus ici: 

jmap -heap $MY_PID 2>/dev/null | sed -ne '/Heap Configuration/,$p';
jmap -permstat $MY_PID
 2
Author: sjas, 2017-06-11 13:53:55

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 ensuite garantir et également 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 comparer grossièrement VIRT (alloué et partagé) et RES (réel utilisé) par rapport aux valeurs jstat:

Pour Java 8, voir jstat pour ces valeurs signifient réellement. En supposant que vous exécutez une classe simple sans mmap ni traitement de fichiers.

$ 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

( à peu près près et en dessous de la mémoire VIRT)

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

(à peu près proche de la mémoire RES)

"Ne me citez pas à ce sujet" mais VIRT mem est à peu près proche ou supérieur à la mémoire maximale allouée mais tant que la mémoire utilisée est libre/disponible en mémoire physique, JVM ne lève pas d'exception de mémoire. En fait, la mémoire maximale n'est même pas vérifié par rapport à la mémoire physique au démarrage de la JVM même avec swap off sur le système d'exploitation. Une meilleure explication de la mémoire virtuelle réellement utilisée par un processus Java est discutée ici.

 2
Author: kisna, 2018-07-03 09:52:42

Si vous utilisez jrockit, essayez l'outil de 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

 1
Author: guest, 2013-05-17 03:40:39

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

Pour mon cas, j'avais un fichier 10g lu en java et chaque fois que je sortais de l'exception de mémoire. Cela s'est produit lorsque la valeur de la colonne RES a atteint la valeur définie dans l'option -Xmx. Ensuite, en augmentant la mémoire en utilisant l'option -Xmx, tout s'est bien passé.

 1
Author: M. Mashaye, 2015-12-15 18:07:53 
jstat -gccapacity javapid  (ex. stat -gccapacity 28745)
jstat -gccapacity javapid gaps frames (ex.  stat -gccapacity 28745 550 10 )

Exemple 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

 1
Author: Pravin, 2016-12-07 22:02:44