Làm cách nào tôi có thể theo dõi ngăn xếp hiện tại trong Java?

Làm cách nào để có được dấu vết ngăn xếp hiện tại trong Java, như cách bạn có thể làm trong .NET Environment.StackTrace?

Tôi đã tìm thấy Thread.dumpStack()nhưng đó không phải là điều tôi muốn - tôi muốn lấy lại dấu vết ngăn xếp, không in nó ra.

Bạn có thể dùng Thread.currentThread().getStackTrace() .

Điều đó trả về một mảng StackTraceElements đại diện cho dấu vết ngăn xếp hiện tại của một chương trình.

Thread.currentThread().getStackTrace();

sẽ ổn nếu bạn không quan tâm yếu tố đầu tiên của ngăn xếp là gì.

new Throwable().getStackTrace();

sẽ có một vị trí xác định cho phương thức hiện tại của bạn, nếu điều đó quan trọng.

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

Thread.currentThread().getStackTrace();

có sẵn kể từ JDK1.5.

Đối với phiên bản cũ hơn, bạn có thể chuyển hướng exception.printStackTrace()đến StringWriter():

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

Bạn có thể sử dụng commons của Apache cho điều đó:

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

Trên Android một cách dễ dàng hơn nhiều là sử dụng điều này:

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

Để có được dấu vết ngăn xếp của tất cả các luồng, bạn có thể sử dụng tiện ích jstack, JConsole hoặc gửi tín hiệu diệt muỗi (trên hệ điều hành Posix).

Tuy nhiên, nếu bạn muốn thực hiện việc này theo lập trình, bạn có thể thử sử dụng ThreadMXBean:

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

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

Như đã đề cập, nếu bạn chỉ muốn theo dõi ngăn xếp của luồng hiện tại thì dễ dàng hơn nhiều - Chỉ cần sử dụng Thread.currentThread().getStackTrace();

Một giải pháp khác (chỉ có 35 31 ký tự):

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

Ngớ ngẩn với tôi, nó Thread.currentThread().getStackTrace();

Tony, như một bình luận cho câu trả lời được chấp nhận, đã đưa ra câu trả lời có vẻ là câu trả lời hay nhất thực sự trả lời câu hỏi của OP :

Arrays.toString(Thread.currentThread().getStackTrace()).replace( ',', '\n' );

... OP KHÔNG hỏi làm thế nào để có được một Stringdấu vết từ ngăn xếp từ một Exception. Và mặc dù tôi là một fan hâm mộ lớn của Apache Commons, khi có một thứ đơn giản như ở trên thì không có lý do hợp lý nào để sử dụng một thư viện bên ngoài.

Tôi khẳng định rằng

  Thread.dumpStack()

là một cách dễ dàng hơn và có lợi thế là không thực sự xây dựng một ngoại lệ hoặc có thể ném được khi có thể không có vấn đề gì cả, và đáng kể hơn nhiều.

Bắt stacktrace:

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

In ngăn xếp (JAVA 8+):

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

In stacktrage (JAVA 7):

StringBuilder sb = new StringBuilder();

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

Trong Java 9 có một cách mới:

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

Tôi có một phương thức tiện ích trả về một chuỗi với 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();
}

Và chỉ cần đăng nhập như ...

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

Để xâu chuỗi với ổi:

Throwables.getStackTraceAsString(new Throwable())

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

hoặc là

Thread.currentThread().getStackTrace()

Có lẽ bạn có thể thử điều này:

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

Chuỗi 'errorDetail' chứa stacktrace.

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

Phần tử cuối cùng của mảng biểu thị phần dưới cùng của ngăn xếp, đây là cách gọi phương thức gần đây nhất trong chuỗi.

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

lặp qua StackTraceEuity và nhận kết quả mong muốn của bạn.

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

Tôi đã sử dụng câu trả lời từ trên và thêm định dạng

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

Bạn có thể sử dụng tiện ích jstack nếu bạn muốn kiểm tra ngăn xếp cuộc gọi hiện tại của quy trình của mình.

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

Đây là một bài viết cũ, nhưng đây là giải pháp của tôi:

Thread.currentThread().dumpStack();

Thêm thông tin và nhiều phương pháp khác tại đó: http://javarevisited.blogspot.fr/2013/04/how-to-get-civerse-stack-trace-in-java-thread.html

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

Điều này sẽ giúp bạn in dấu vết ngăn xếp mà không cần vòng lặp.