Just use new Throwable(). printStackTrace() method and it will print complete stack trace from where a method is called, into the console.
Using printStackTrace() method − It print the name of the exception, description and complete stack trace including the line where exception occurred. Using toString() method − It prints the name and description of the exception. Using getMessage() method − Mostly used. It prints the description of the exception.
You can use Thread. currentThread(). getStackTrace() . That returns an array of StackTraceElement s that represent the current stack trace of a program.
Yes, simply use
Thread.dumpStack()
You can also try Thread.getAllStackTraces()
to get a map of stack traces for all the threads that are alive.
If you want the trace for just the current thread (rather than all the threads in the system, as Ram's suggestion does), do:
Thread.currentThread().getStackTrace()
To find the caller, do:
private String getCallingMethodName() {
StackTraceElement callingFrame = Thread.currentThread().getStackTrace()[4];
return callingFrame.getMethodName();
}
And call that method from within the method that needs to know who its caller is. However, a word of warning: the index of the calling frame within the list could vary according to the JVM! It all depends on how many layers of calls there are within getStackTrace before you hit the point where the trace is generated. A more robust solution would be to get the trace, and iterate over it looking for the frame for getCallingMethodName, then take two steps further up to find the true caller.
You can get a stack trace like this:
Throwable t = new Throwable();
t.printStackTrace();
If you want to access the frame, you can use t.getStackTrace() to get an array of stack frames.
Be aware that this stacktrace (just like any other) may be missing some frames if the hotspot compiler has been busy optimizing things.
Notice that Thread.dumpStack() actually throws an exception:
new Exception("Stack trace").printStackTrace();
Java 9 introduced the StackWalker
and supporting classes for walking the stack.
Here are a few snippets from the Javadoc:
The
walk
method opens a sequential stream ofStackFrames
for the current thread and then applies the given function to walk theStackFrame
stream. The stream reports stack frame elements in order, from the top most frame that represents the execution point at which the stack was generated to the bottom most frame. TheStackFrame
stream is closed when the walk method returns. If an attempt is made to reuse the closed stream,IllegalStateException
will be thrown....
To snapshot the top 10 stack frames of the current thread,
List<StackFrame> stack = StackWalker.getInstance().walk(s -> s.limit(10).collect(Collectors.toList()));
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With