hilos Inspección de Java en Linux utilizando la parte superior

Question

estoy inspeccionando un proceso de Java en Linux usando

top -H 

Sin embargo, no se puede leer el nombre de la rosca en la columna de "comando" (porque es demasiado largo). Si utilizo 'c' para expandir el nombre completo del proceso, aún me queda mucho tiempo para que encaje.

¿Cómo puedo obtener el nombre completo del comando?

Answer 1

Puede inspeccionar hilos de java con la herramienta jstack. Enumerará los nombres, stacktraces y otra información útil de todos los hilos que pertenecen al proceso especificado pid.

Editar: El parámetro nid en el volcado de subprocesos de jstack es la versión hexadecimal del LWP que se muestra arriba en la columna pid para subprocesos.

Answer 2

¿El aumento de la variable de entorno COLUMNS le proporciona más información en la pantalla?

Answer 3

Los hilos no tienen nombres en lo que se refiere al kernel; solo tienen números de identificación. La JVM asigna nombres a los hilos, pero eso son datos internos privados dentro del proceso, que el programa "superior" no puede acceder (y de todos modos no conoce).

Answer 4

Esto podría ser un poco viejo, pero esto es lo que hice para fusionar un poco la parte superior y jstack juntos. Usé dos scripts, pero estoy seguro de que todo podría hacerse en uno.

En primer lugar, guardar la salida de la parte superior con los PID para mis hilos de Java en un archivo y guardar la salida jstack en otro archivo:

#!/bin/sh 
top -H -b -n 1 | grep java > /tmp/top.log 
jstack -l `ps fax | grep java | grep tomcat | sed "s/ *\([0-9]*\) .*/\1/g"` > /tmp/jstack.log 

Luego uso un script en perl para llamar a la escritura del golpe (cpu-java.sh llamado aquí) y un poco fusionar los dos archivos (/tmp/top.log y /tmp/jstack.log):

#!/usr/bin/perl 
system("sh cpu-java.sh"); 
open LOG, "/tmp/top.log" or die $!; 
print "PID\tCPU\tMem\tJStack Info\n"; 
while ($l = <LOG>) { 
    $pid = $l; 
    $pid =~ s/root.*//g; 
    $pid =~ s/ *//g; 
    $hex_pid = sprintf("%#x", $pid); 
    @values = split(/\s{2,}/, $l); 
    $pct = $values[4]; 
    $mem = $values[5]; 
    open JSTACK, "/tmp/jstack.log" or die $!; 
    while ($j = <JSTACK>){ 
     if ($j =~ /.*nid=.*/){ 
      if ($j =~ /.*$hex_pid.*/){ 
       $j =~ s/\n//; 
       $pid =~ s/\n//; 
       print $pid . "\t" . $pct . "\t" . $mem . "\t" . $j . "\n"; 
      } 
     } 
    } 
    close JSTACK; 
} 
close LOG; 

La salida me ayuda para saber qué temas están acaparando mi cpu :

PID  CPU Mem JStack Info 
22460 0 8.0 "main" prio=10 tid=0x083cb800 nid=0x57bc runnable [0xb6acc000] 
22461 0 8.0 "GC task thread#0 (ParallelGC)" prio=10 tid=0x083d2c00 nid=0x57bd runnable 
22462 0 8.0 "GC task thread#1 (ParallelGC)" prio=10 tid=0x083d4000 nid=0x57be runnable 
22463 0 8.0 "GC task thread#2 (ParallelGC)" prio=10 tid=0x083d5800 nid=0x57bf runnable 
22464 0 8.0 "GC task thread#3 (ParallelGC)" prio=10 tid=0x083d7000 nid=0x57c0 runnable 
... 

Luego puedo volver a /tmp/jstack.log y echar un vistazo al seguimiento de la pila para el hilo problemático y tratar de averiguar qué está pasando desde allí. Por supuesto, esta solución depende de la plataforma, pero debería funcionar con la mayoría de los sabores de * nix y algunos ajustes aquí y allá.

Answer 5

He creado un comando de tipo superior específicamente para visualizar subprocesos Java ordenados por uso de CPU y publicado el código fuente en: https://github.com/jasta/jprocps. La sintaxis de línea de comandos no es tan rico como la parte superior, pero es compatible con algunos de los mismos comandos:

 
jtop -n 1 

Salida de ejemplo (mostrando hormigas y IntelliJ marcha):

 
    PID TID USER  %CPU %MEM THREAD 
13480 13483 jasta  104 2.3 main 
13480 13497 jasta  86.3 2.3 C2 CompilerThread1 
13480 13496 jasta  83.0 2.3 C2 CompilerThread0 
4866 4953 jasta  1.0 13.4 AWT-EventQueue-1 12.1.4#IC-129.713, eap:false 
4866 14154 jasta  0.9 13.4 ApplicationImpl pooled thread 36 
4866 5219 jasta  0.8 13.4 JobScheduler pool 5/8 

De esta salida , Puedo levantar el rastro de la pila del subproceso en jconsole o jstack manualmente y descubrir qué está pasando.

Answer 6

Con OpenJDK en Linux, los nombres JavaThread no se propagan a native threads, no se puede ver el nombre del hilo java mientras se inspeccionan los hilos nativos con cualquier herramienta.

Sin embargo, hay algunos trabajos en curso:

• https://bugs.openjdk.java.net/browse/JDK-7102541
• http://mail.openjdk.java.net/pipermail/hotspot-dev/2012-July/006211.html

Personalmente, creo que la herramienta de desarrollo de OpenJDK lento por lo que acabo de aplicar parches a mí mismo.

Answer 7

Pregunta anterior, pero tuve el mismo problema con top.

Resulta, puede salida de desplazamiento de arriba a la derecha, simplemente usando las teclas de cursores :)

(pero lamentablemente no habrá ningún hilo nombre mostrado)

Answer 8

Como hasta donde yo descubrí jstack is outdated como de JDK 8. lo que se utiliza para recuperar todos los nombres de hebra Java es:

<JDK_HOME>/bin/jcmd <PID> Thread.print 

Comprobar jcmd documentation por más.

Answer 9

Este script de shell combina el resultado de jstack y top para mostrar los hilos de Java por uso de CPU. Espera un argumento, el usuario de la cuenta que posee los procesos.

Nombre: jstack-top.sh

#!/bin/sh 
# 
# jstack-top - join jstack and top to show cpu usage, etc. 
# 
# Usage: jstack-top <user> | view - 
# 

USER=$1 
TOPS="/tmp/jstack-top-1.log" 
JSKS="/tmp/jstack-top-2.log" 

PIDS="$(ps -u ${USER} --no-headers -o pid:1,cmd:1 | grep 'bin/java' | grep -v 'grep' | cut -d' ' -f1)" 
if [ -f ${JSKS} ]; then 
    rm ${JSKS} 
fi 
for PID in ${PIDS}; do 
    jstack -l ${PID} | grep "nid=" >>${JSKS} 
done 

top -u ${USER} -H -b -n 1 | grep "%CPU\|java" | sed -e 's/[[:space:]]*$//' > ${TOPS} 
while IFS= read -r TOP; do 
    NID=$(echo "${TOP}" | sed -e 's/^[[:space:]]*//' | cut -d' ' -f1) 
    if [ "${NID}" = "PID" ]; then 
     JSK="" 
     TOP="${TOP} JSTACK" 
    else 
     NID=$(printf 'nid=0x%x' ${NID}) 
     JSK=$(grep "${NID} " ${JSKS}) 
    fi 
    echo "${TOP} ${JSK}" 
done < "${TOPS}"