see - limit heap size java

¿Herramienta de línea de comandos para encontrar el tamaño del almacenamiento dinámico de Java y la memoria utilizada(Linux)?

Question

¿Hay una herramienta de línea de comandos (Linux) para verificar el tamaño del almacenamiento dinámico (y la memoria utilizada) de una aplicación Java?

He intentado con jmap. Pero da información. sobre áreas de memoria interna como Eden / PermGen, etc., que no es útil para mí.

Estoy buscando algo como:
Memoria máxima: 1GB
Memoria mínima: 256 MB
Heap Memory: 700 MB
Memoria utilizada: 460 MB

Eso es todo. Sé que puedo ver esto en JConsole, etc., pero necesito una herramienta de línea de comandos (no puedo habilitar JMX, etc.)

¿Alguna herramienta / comando de este tipo?

Answer 1

Cualquier enfoque debería darle aproximadamente el mismo número. Siempre es una buena idea asignar el montón usando -X..m-X..x para todas las generaciones. A continuación, puede garantizar y también hacer ps para ver qué parámetros se aprobaron y, por lo tanto, se utilizaron.

Para los usos reales de la memoria, puede comparar aproximadamente VIRT (asignado y compartido) y RES (actual usado) comparar con los valores de jstat también:

Para Java 8, consulte https://docs.oracle.com/javase/8/docs/technotes/tools/unix/jstat.html para estos valores realmente significan. Suponiendo que ejecute una clase simple sin mmap o procesamiento de archivos. 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 EOM 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 (roughly close and below to VIRT memory) **Max(Min, Used)**: 215040 + 512 + 512 + 67072 + 430080 + 39680 + 4864 = ~ 1GB (roughly close to RES memory)

"No me cite en esto", pero VIRT mem está más o menos cerca de la memoria máxima asignada, pero mientras la memoria utilizada sea ​​libre / disponible en la memoria física, JVM no arroja una excepción de memoria. De hecho, la memoria máxima ni siquiera se compara con la memoria física en el arranque de la JVM, incluso con el intercambio desactivado en el sistema operativo. Una mejor explicación de qué memoria virtual realmente utiliza un proceso Java se trata aquí: uso de memoria virtual de Java en Linux, demasiada memoria utilizada

Answer 2

En términos de tamaño de almacenamiento dinámico de Java, en Linux, puede usar

ps aux | grep java

o

ps -ef | grep java

y busque -Xms, -Xmx para averiguar el tamaño de almacenamiento dinámico inicial y máximo especificado.

Sin embargo, si -Xms o -Xmx está ausente para el proceso de Java que le interesa, significa que su proceso de Java está usando los tamaños de almacenamiento dinámico predeterminados. Puede usar el siguiente comando para averiguar los tamaños predeterminados.

java -XX:+PrintFlagsFinal -version | grep HeapSize

o un jvm particular, por ejemplo,

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

y busque InitialHeapSize y MaxHeapSize, que está en bytes.

Answer 3

Este comando muestra los tamaños de montón configurados en bytes.

java -XX:+PrintFlagsFinal -version | grep HeapSize

Funciona en Amazon AMI en EC2 también.

Answer 4

Hay una herramienta de línea de comandos con un aspecto visual - jvm-mon . Es una herramienta de monitoreo JVM para la línea de comandos que desafortunadamente:

• uso del montón, tamaño y máximo
• procesos jvm
• uso de CPU y GC
• hilos superiores

Las métricas y los gráficos se actualizan mientras la herramienta está abierta.

Muestra: jvm-mon

Answer 5

Primero obtenga la identificación del proceso, el primer número del proceso enumerado, de una de las siguientes opciones (o simplemente use ps aux | grep java , si lo prefiere)

jps -lvm

Luego use la ID del proceso aquí:

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

Answer 6

Prueba esto, funcionó en Ubuntu y RedHat:

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

Para ventanas:

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

Para Mac

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

La salida de todos estos comandos se asemeja a la salida siguiente:

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)

Para encontrar el tamaño en MB, divida el valor con (1024 * 1024).

Answer 7

Si usa jrockit pruebe la herramienta de línea de comandos jrcmd. Por ejemplo:

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

Para obtener más comandos, como heap_diagnostics, use "jrcmd help" para listarlos.

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

Answer 8

Sin usar JMX, que es lo que usan la mayoría de las herramientas, todo lo que puede hacer es usar

jps -lvm

e inferir que la configuración será desde las opciones de línea de comando.

No puede obtener información dinámica sin JMX por defecto, pero puede escribir su propio servicio para hacerlo.

Por cierto: prefiero usar VisualVM en lugar de JConsole.

Answer 9

Tarde en la fiesta, pero una solución muy simple es usar el script jpsstat.sh. Proporciona una simple memoria de corriente en vivo, memoria máxima y detalles de uso de la CPU .

• Goto el proyecto GitHub y descarga el archivo jpsstat.sh
• Haga clic derecho en jpsstat.sh y goto la pestaña de permisos y hágala ejecutable
• Ahora ejecute el script usando el siguiente comando ./jpsstat.sh

Aquí está la salida de muestra del 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

Answer 10

Usar el comando top es la forma más sencilla de verificar el uso de memoria del programa. RES columna RES muestra la memoria física real que está ocupada por un proceso.

Para mi caso, tenía un archivo 10g leído en java y cada vez que recibí una excepción de OutOfMemory. Esto sucedió cuando el valor en la columna RES llegó al valor establecido en la opción -Xmx . Luego, al aumentar la memoria con la opción -Xmx , todo salió bien.

Answer 11

jvmtop es una herramienta de línea de comandos que proporciona una vista en vivo en varias métricas, incluido el montón.

Ejemplo de salida del modo de visión general de 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

Answer 12

Cada proceso de Java tiene un pid , que primero debe encontrar con el comando jps .

Una vez que tenga el pid, puede usar jstat -gc [insert-pid-here] para buscar estadísticas del comportamiento del montón recolectado de basura.

• jstat -gccapacity [insert-pid-here] presentará información sobre generación de grupos de memoria y capacidades de espacio.

• jstat -gcutil [insert-pid-here] presentará la utilización de cada generación como un porcentaje de su capacidad. Útil para obtener una vista rápida del uso.

Vea los documentos jstat en el sitio de Oracle.

Answer 13

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

Muestra O / P del comando anterior

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

Obtenga más detalles al respecto en http://docs.oracle.com/javase/1.5.0/docs/tooldocs/share/jstat.html