Hay una Herramienta de línea de Comandos (Linux) para comprobar el Tamaño de la pila (y Memoria) de una Aplicación Java?

He intentado a través de jmap. Pero se da la información. acerca de la memoria interna áreas como Eden/PermGen etc., que no es útil para mí.

Estoy buscando algo como:

  • Máximo de Memoria: 1GB
  • Min de la Memoria: 256 MB
  • Montón de Memoria: 700 MB
  • Uso de la Memoria: 460 MB

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

¿Conoces alguna herramienta o comando?

InformationsquelleAutor Jasper | 2012-10-09

16 Comentarios

  1. 136

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

    Una vez que usted tiene el pid, puede utilizar jstat -gc [insert-pid-here] a encontrar estadísticas de la conducta de la basura que se recoge montón.

    • jstat -gccapacity [insert-pid-here] presentará información sobre la memoria de la piscina de la generación y la capacidad espacial.

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

    Ver jstat docs en Oracle sitio.

    • Hay una recomendación que las opciones de jstat se debe utilizar con el fin de verificar solo la memoria general, el uso de la JVM? Digamos que usted inicie la JVM con Xms=4g y Xmx=4g y desea ver, la cantidad de memoria de que ya se haya utilizado?
    • «jstat -gcutil <pid> 250 N» fue muy útil para tomar N muestras con intervalos de 250 ms y mostrar los resultados como porcentajes de los espacios correspondientes. Gracias.
    • Vale la pena destacar la cita de jstat Oracle Java 8 manual de página: This command is experimental and unsupported.
    • awk 'print {$3+$4+$6+$8}' puede imprimir resumen el uso de Java 8 jstat columnas
    • Tuvo problemas con las otras respuestas, pero un básico ps -ef | grep java me mostró la vm args, que en mi caso se incluye el -Xmx valor, que era todo lo que necesitaba.
    • debe ser awk '{print $3+$4+$6+$8}'
    • y también, debe ser awk '{print $3+$9}' también conocida como NGC + OGC, si no consideramos perm espacio.
    • o awk 'NR>1 {print $3+$4+$6+$8}' a saltar la primera línea con los títulos de las columnas

  2. 61

    jvmtop es una herramienta de línea de comandos que proporciona un live-view en varias métricas, incluyendo montón.

    Ejemplo de salida de la VM modo de visión general:

     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
    • De hecho, es una gran herramienta, tipo de htop pero con métricas de jstat. Gracias por la sugerencia, @MRalwasser .
  3. 56

    Este comando muestra la configuración montón de tamaños en bytes.

    java -XX:+PrintFlagsFinal -version | grep HeapSize

    Funciona en Amazon AMI en EC2 así.

    • Esto no responde a la pregunta, que específicamente se pregunta cómo comprobar el uso del montón de un proceso. El comando listas de JVM valores predeterminados en todos los procesos.
    • Sin embargo, es muy útil la respuesta para mí venir a esta página a través de la búsqueda de google sobre cómo encontrar el montón global de tamaño.
  4. 36

    Tratar de esto, trabajó en Ubuntu y RedHat:

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

    Para Windows:

    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 similar a la siguiente resultado:

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

    • Cómo encontrar el uso de memoria separados por montón, permsize,… de java proceso por el pid ?
    • Este es el tamaño de pila predeterminado. Para encontrar el uso de la aplicación en ejecución, deberá hacerlo dentro de los códigos o puede utilizar jconsole. Esto es lo que sé también debe haber muchas otras maneras.
    • Uso jstat -gc <vmid> para la ejecución de aplicaciones.
  5. 24

    Sin el uso de JMX, que es lo que la mayoría de las herramientas de uso, todo lo que puedes hacer es usar

    jps -lvm

    y deducir que la configuración será a partir de las opciones de línea de comandos.

    Usted no puede obtener la información dinámica sin JMX por defecto, pero usted puede escribir su propio servicio para ello.

    BTW: yo prefiero usar VisualVM en lugar de JConsole.

  6. 19

    No es una herramienta de línea de comandos con un aspecto visual – jvm-mon. Es una JVM de la herramienta de monitoreo para la línea de comandos que disaplys:

    • montón de uso, tamaño y max
    • jvm procesos
    • la cpu y de la GC uso
    • hilos superiores

    Las métricas y gráficos actualizar mientras la herramienta está abierta.

    Ejemplo: Herramienta de línea de comandos para encontrar Java Tamaño de la pila y la Memoria Utilizada (Linux)?

    • Sólo para señalar que la jvm-lun sólo se ejecuta para Java8
  7. 7

    Tarde en la fiesta, pero una solución muy sencilla es utilizar el jpsstat.sh secuencia de comandos. Se proporciona un simple vivir actual de la memoria, máximo de memoria y el uso de la cpu detalles.

    • Goto GitHub del proyecto y descarga la jpsstat.sh archivo
    • Clic derecho en jpsstat.sh y goto permisos ficha y hacerlo ejecutable
    • Ahora Ejecute la secuencia de comandos mediante el comando siguiente:. /jpsstat.sh

    Aquí está la muestra de la salida de secuencia de comandos –

    =====  ======  =======  =======  =====
     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
    • no parece funcionar fuera de la caja en un SUSE Linux (línea 38: declarar: -Una: opción no válida)
    • parece que el error en la matriz asociativa de declaración, el cual necesita de bash >= 4. También otro problema puede ser debido a la ejecución de la secuencia de comandos como «sh jpsstat.sh» . Si es así, pruebe a ejecutar la secuencia de comandos «./jpsstat.sh».
  8. 5

    Cualquier enfoque debe dar aproximadamente el mismo número. Siempre es una buena idea asignar el montón mediante -X..m -X..x para todas las generaciones. Usted puede, a continuación, garantía y también hacer ps a ver qué parámetros se pasan y por lo tanto ser utilizado.

    De memoria real de los usos, usted puede casi comparar VIRT (asignados y compartido) y RES (real utilizado) comparar contra el jstat valores así:

    Para Java 8, ver jstat para estos valores en realidad significa. Suponiendo que ejecutar una clase simple con ningún 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     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

    (aproximadamente cerca y a continuación a VIRT de memoria)

    Max(Min, Usa):

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

    (aproximadamente cerca de RES memoria)

    «No me fijé en esto», pero VIRT mem es aproximadamente cerca o más del máximo de memoria asignada pero mientras memoria que se usa libre/disponible en física de la memoria, JVM no tirar de memoria excepción. De hecho, el máximo de memoria no está aún marcada en contra de memoria física en el inicio de la JVM incluso con el swap de descuento en OS. Una mejor explicación de lo que es la memoria Virtual realmente utilizados por un proceso Java se discute aquí.

  9. 3

    De Java8 y por encima de, puede usar el siguiente comando:

    jcmd JAVA_PROCESS_ID GC.heap_info

    Puede referirse a la suma de, el total de memoria utilizada y de la salida.

    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

    Para más detalles sobre jcmd de comandos, visite el enlace: https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/tooldescr006.html

    • Necesitas corregir tu comentario. GC.heap_info está disponible en Java 9 y superiores. No está disponible en el Java 8. Vea otro hilo aquí: stackoverflow.com/questions/41891127/…
    • Soy capaz de utilizar el comando en jdk1.8.0_172. /Biblioteca/Java/JavaVirtualMachines/jdk1.8.0_172.jdk/Contenido/Home/bin/jcmd 98270 GC.heap_info. Por favor, si usted puede, Añadir la información a que se refiere el hilo, así como no tengo suficiente reputación como la de ahora, para agregar un comentario allí.
    • ¿Utilizas Mac? ¿El uso de Oracle JDK? No sé cómo puede estar disponible en su jdk1.8.0_172, Oracle documentado esta característica sólo en Java 9 y hasta: docs.oracle.com/javase/9/tools/jcmd.htm. No es en el Oracle JDK documentación de Java 8. No se menciona en el enlace que te dio en la parte inferior: docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/…
    • Una pregunta más. Por favor, compruebe el JDK versión que se está ejecutando el proceso de 98270 en su ejemplo. jcmd pone a disposición de los comandos de la JVM del proceso (en su caso 98270). Si el proceso de 98270 proceso se ejecuta con diferentes JDK (JDK 9 o superior), usted verá GC.heap_info de comandos disponibles incluso en JCMD sí es de Java 8. Los comandos disponibles pueden ser diferentes para los diferentes procesos. Para obtener los comandos disponibles ejecutar: jcmp <PID> ayuda.
    • Sí, estoy usando Mac. (Puede que me haga saber, cómo puede hacer la diferencia). Sí, creo que estoy en el uso de oracle jdk (puede que me ayude a saber, lo que todos los demás están disponibles, y cómo puedo comprobar). El proceso es el uso de jdk1.8.0_172 (comprobado en múltiples procesos java). Tengo estos 5 comandos extra que se documentan en mi se refiere el enlace, en jcmd <PID> ayuda -> VM.classloader_stats, GC.rotate_log, GC.finalizer_info, GC.heap_info, VM.dynlibs
    • FWIW, GC.heap_info es definitivamente disponible en OpenJDK 8 también. Tal vez sólo en las últimas versiones? Yo estoy usando esta: 8u191-b12-2ubuntu0.18.04.1

  10. 2

    Primero obtener el identificador de proceso, el primer número de el proceso indicado, a partir de uno de los siguientes: (o, simplemente, utilizar ps aux | grep java, si lo prefieres)

    jps -lvm

    A continuación, utilizar el proceso de IDENTIFICACIÓN de aquí:

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

    En mi caso necesitaba para comprobar las banderas en el interior de un contenedor docker que no tenía la mayoría de los servicios públicos básicos (sal, pstree…)

    Utilizando jps tengo el PID de la JVM ejecuta (en mi caso 1) y, a continuación, con jcmd 1 VM.flags tengo las banderas de la ejecución de la JVM.

    Depende de lo que los comandos que usted tiene disponible, pero esto podría ayudar a alguien. 🙂

  12. 1

    Si el uso de jrockit probar el jrcmd herramienta de línea de comandos. 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, el uso de «jrcmd ayudar» a una lista de ellos.

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

  13. 1

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

    Para mi caso, tuve un 10g de lectura de archivos en java, y cada vez que tengo outOfMemory excepción. Esto sucedió cuando el valor en el RES columna alcanzado el valor establecido en -Xmx opción. A continuación, mediante el aumento de la memoria usando -Xmx opción todo salió bien.

    • comando superior está mostrando lo mucho que OS es dada a la JVM. esta gente está preguntando cómo podemos ver el montón de espacio de uso dentro de la JVM. La JVM es el uso de 10g no significa que el real montón de espacio está lleno de 10g datos, ya que la jvm casi nunca vuelven a su memoria de sistema operativo desde el montón hasta que matar el proceso.
  14. 1
    jstat -gccapacity javapid  (ex. stat -gccapacity 28745)
    jstat -gccapacity javapid gaps frames (ex.  stat -gccapacity 28745 550 10 )

    De la muestra O/P de comando de arriba

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

    Obtener más detalles acerca de esto en http://docs.oracle.com/javase/1.5.0/docs/tooldocs/share/jstat.html

  15. 1

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

    ps aux | grep java

    o

    ps -ef | grep java

    y buscar -Xms, -Xmx para averiguar la inicial y tamaño máximo de pila especificado.

    Sin embargo, si -Xms o -Xmx está ausente durante el proceso Java usted está interesado en, significa que su proceso Java está utilizando el valor predeterminado montón de tamaños. Puede utilizar el siguiente comando para averiguar los tamaños predeterminados.

    java -XX:+PrintFlagsFinal -version | grep HeapSize

    o un particular jvm, por ejemplo,

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

    y buscar InitialHeapSize y MaxHeapSize, que es en bytes.

  16. 1

    No hay ninguna herramienta de este tipo hasta ahora para imprimir el montón de memoria en el formato en el que solicitó
    La Única y la única forma de impresión es escribir un programa en java con la ayuda de la Clase en tiempo de ejecución,

    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);
    }

    }

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

Dejar respuesta

Please enter your comment!
Please enter your name here