stack-trace - que - pilas con stack en java

Obtener el seguimiento actual de la pila en Java

Question

¿Cómo obtengo el seguimiento de pila actual en Java, como en .NET puedes hacer Environment.StackTrace ?

Por cierto, Thread.dumpStack() no es lo que quiero, quiero recuperar el seguimiento de la pila , no imprimirlo.

Answer 1

En Android, una forma mucho más fácil es usar esto:

import android.util.Log;
String stackTrace = Log.getStackTraceString(exception); 

Answer 2

En Java 9 hay una nueva forma:

public static void showTrace() {

  List<StackFrame> frames =
    StackWalker.getInstance( Option.RETAIN_CLASS_REFERENCE )
               .walk( stream  -> stream.collect( Collectors.toList() ) );

  for ( StackFrame stackFrame : frames )
    System.out.println( stackFrame );
}

Answer 3

Este es un post viejo, pero aquí está mi solución:

Thread.currentThread().dumpStack();

Más información y más métodos allí: http://javarevisited.blogspot.fr/2013/04/how-to-get-current-stack-trace-in-java-thread.html

Answer 4

Otra solución (solo 35 31 caracteres):

new Exception().printStackTrace();   
new Error().printStackTrace();

Answer 5

Para ensartar con guayaba:

Throwables.getStackTraceAsString(new Throwable())

Answer 6

Para obtener el seguimiento de la pila de todos los subprocesos, puede utilizar la utilidad jstack, JConsole o enviar una señal de cancelación de comillas (en un sistema operativo Posix).

Sin embargo, si desea hacer esto mediante programación, puede intentar usar ThreadMXBean:

ThreadMXBean bean = ManagementFactory.getThreadMXBean();
ThreadInfo[] infos = bean.dumpAllThreads(true, true);

for (ThreadInfo info : infos) {
  StackTraceElement[] elems = info.getStackTrace();
  // Print out elements, etc.
}

Como se mencionó, si solo desea que el seguimiento de la pila del subproceso actual sea mucho más fácil, solo use Thread.currentThread().getStackTrace() ;

Answer 7

Puede usar Thread .currentThread().getStackTrace() .

Eso devuelve una matriz de StackTraceElement s que representan el seguimiento de pila actual de un programa.

Answer 8

Puede usar la utilidad jstack si desea verificar la pila de llamadas actual de su proceso.

Usage:
    jstack [-l] <pid>
        (to connect to running process)
    jstack -F [-m] [-l] <pid>
        (to connect to a hung process)
    jstack [-m] [-l] <executable> <core>
        (to connect to a core file)
    jstack [-m] [-l] [server_id@]<remote server IP or hostname>
        (to connect to a remote debug server)

Options:
    -F  to force a thread dump. Use when jstack <pid> does not respond (process is hung)
    -m  to print both java and native frames (mixed mode)
    -l  long listing. Prints additional information about locks
    -h or -help to print this help message

Answer 9

Puedes usar los comunes de Apache para eso:

String fullStackTrace = org.apache.commons.lang3.exception.ExceptionUtils.getStackTrace(e);

Answer 10

Sugiero que

  Thread.dumpStack()

es una forma más fácil y tiene la ventaja de no construir realmente una excepción o un objeto ejecutable cuando puede que no haya ningún problema, y ​​es considerablemente más importante.

Answer 11

Tal vez podrías probar esto:

catch(Exception e)
{
    StringWriter writer = new StringWriter();
    PrintWriter pw = new PrintWriter(writer);
    e.printStackTrace(pw);
    String errorDetail = writer.toString();
}

La cadena ''errorDetail'' contiene el stacktrace.

Answer 12

Tengo un método de utilidad que devuelve una cadena con stacktrace:

static String getStackTrace(Throwable t) {
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw, true);
    t.printStackTrace(pw);
    pw.flush();
    sw.flush();
    return sw.toString();
}

Y solo logit como ...

... 
catch (FileNotFoundException e) {
    logger.config(getStackTrace(e));
}

Answer 13

Tonto, es Thread.currentThread().getStackTrace();

Answer 14

Tony, como un comentario a la respuesta aceptada, ha dado la que parece ser la mejor respuesta que responde realmente a la pregunta del OP :

Arrays.toString(Thread.currentThread().getStackTrace());

... el OP NO preguntó cómo obtener una String de la traza de pila de una Exception . Y aunque soy un gran fan de Apache Commons, cuando hay algo tan simple como lo anterior no hay razón lógica para usar una biblioteca externa.

Answer 15

Utilicé las respuestas de arriba y añadí formato.

public final class DebugUtil {

    private static final String SEPARATOR = "/n";

    private DebugUtil() {
    }

    public static String formatStackTrace(StackTraceElement[] stackTrace) {
        StringBuilder buffer = new StringBuilder();
        for (StackTraceElement element : stackTrace) {
            buffer.append(element).append(SEPARATOR);
        }
        return buffer.toString();
    }

    public static String formatCurrentStacktrace() {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        return formatStackTrace(stackTrace);
    }
}

Answer 16

System.out.println(Arrays.toString(Thread.currentThread().getStackTrace()));

Esto le ayudará a imprimir el seguimiento de la pila sin bucle.

Answer 17

Obteniendo stacktrace:

StackTraceElement[] ste = Thread.currentThread().getStackTrace();

Estampado de pila (JAVA 9+):

Arrays.asList(ste).stream().forEach(System.out::println);

Impresión stacktrage (JAVA 7):

StringBuilder sb = new StringBuilder();

for (StackTraceElement st : ste) {
    sb.append(st.toString() + System.lineSeparator());
}
System.out.println(sb);

Answer 18

StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();

El último elemento de la matriz representa la parte inferior de la pila, que es la invocación de método menos reciente en la secuencia.

A StackTraceElement has getClassName(), getFileName(), getLineNumber() and getMethodName().

recorra StackTraceElement y obtenga el resultado deseado.

for (StackTraceElement ste : stackTraceElements ) 
{
    //do your stuff here...
}

Answer 19

Thread.currentThread().getStackTrace();

está bien si no te importa cuál es el primer elemento de la pila.

new Throwable().getStackTrace();

Tendrá una posición definida para su método actual, si eso importa.

Answer 20

Thread.currentThread().getStackTrace();

está disponible desde JDK1.5.

Para una versión anterior, puede redireccionar exception.printStackTrace() a un StringWriter() :

StringWriter sw = new StringWriter();
new Throwable("").printStackTrace(new PrintWriter(sw));
String stackTrace = sw.toString();

Answer 21

for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
    System.out.println(ste);
}

Answer 22

try {
}
catch(Exception e) {
    StackTraceElement[] traceElements = e.getStackTrace();
    //...
}

o

Thread.currentThread().getStackTrace()