Analyzing a thread dump is a crucial method for
diagnosing performance issues in a Java application, especially related to
threading and concurrency problems such as deadlocks, excessive thread
contention, and resource bottlenecks. Here's a step-by-step guide on how to
find out performance issues using thread dumps:
What is a Thread Dump?
A thread dump is a snapshot of all the threads running in a
Java Virtual Machine (JVM) at a particular point in time. It provides
information about each thread's state, stack trace, and monitor locks.
When to Take a Thread Dump?
Ø High
CPU Usage: When the application is consuming an unusually high amount of
CPU.
Ø Unresponsiveness:
When the application is slow or not responding.
Ø Deadlocks:
When you suspect deadlocks or resource contention issues.
How to Take a Thread Dump?
You can take a thread dump using various tools:
- JDK
Tools:
ü
jstack: A command-line utility that comes with
the JDK.
sh
jstack -l <pid> |
ü
jcmd: Another command-line utility for various
JVM diagnostics.
sh
jcmd <pid> Thread.print |
- JVisualVM:
A graphical tool that comes with the JDK.
ü
Start jvisualvm, connect to your JVM, and
generate a thread dump from the "Threads" tab.
- Operating
System Commands:
ü
On Unix/Linux:
sh
kill -3 <pid> |
ü
On Windows: Use jvisualvm or jconsole.
Analyzing a Thread Dump
Thread States
Threads can be in different states:
Ø RUNNABLE:
The thread is executing.
Ø BLOCKED:
The thread is waiting for a monitor lock to enter a synchronized block/method.
Ø WAITING:
The thread is waiting indefinitely for another thread to perform a particular
action.
Ø TIMED_WAITING:
The thread is waiting for another thread to perform a particular action for up
to a specified waiting time.
Ø TERMINATED:
The thread has exited.
Key Points to Analyze
- Identify
Blocked Threads:
ü
Look for threads in the BLOCKED state.
ü
Check the "waiting to lock" and
"locked" information to find out what resource is causing the block.
- High
CPU Usage:
ü
Look for threads in the RUNNABLE state and check
their stack traces to see what code they are executing.
ü
Identify if they are stuck in loops or
performing long-running operations.
- Deadlocks:
ü
Search for sections in the thread dump that
explicitly mention deadlocks.
ü
Identify the threads and resources involved in
the deadlock.
- Resource
Contention:
ü
Check for a high number of threads in the
WAITING or TIMED_WAITING state waiting on the same resource.
- Thread
Pools:
ü
Analyze the usage of thread pools (e.g.,
ExecutorService) to see if all threads are busy or idle.
ü
Check for potential thread starvation or
over-utilization.
Example Analysis
Here’s an example snippet from a thread dump with key points
highlighted:
plaintext
"Thread-1" #23 prio=5 os_prio=0
tid=0x000000001d0d4800 nid=0x17fc waiting on condition [0x000000001db7e000] java.lang.Thread.State: TIMED_WAITING
(sleeping) at
java.lang.Thread.sleep(Native Method) at
com.example.MyClass.myMethod(MyClass.java:123) - locked
<0x00000000f47e60f0> (a java.lang.Object) at
com.example.MyClass.run(MyClass.java:456) at
java.lang.Thread.run(Thread.java:748) "Thread-2" #24 prio=5 os_prio=0
tid=0x000000001d0d5000 nid=0x1800 waiting for monitor entry
[0x000000001dc7f000] java.lang.Thread.State: BLOCKED (on object
monitor) at
com.example.MyClass.mySynchronizedMethod(MyClass.java:789) - waiting to
lock <0x00000000f47e60f0> (a java.lang.Object) at
com.example.MyClass.run(MyClass.java:456) at
java.lang.Thread.run(Thread.java:748) |
Steps for Analysis
- Thread
States:
ü
Thread-1 is in a TIMED_WAITING state
because it is sleeping.
ü
Thread-2 is in a BLOCKED state
waiting for the monitor lock on <0x00000000f47e60f0>.
- Identify
Bottlenecks:
ü
Thread-2 is blocked trying to enter
mySynchronizedMethod which is synchronized on the same object
<0x00000000f47e60f0> that Thread-1 has locked.
- Check
Stack Trace:
ü
The stack trace shows where each thread is in
the code.
ü
Thread-1 is holding the lock and
sleeping, which means Thread-2 cannot proceed until Thread-1 finishes
its sleep and releases the lock.
Tools for Analysis
Several tools can help visualize and analyze thread dumps:
Ø Thread
Dump Analyzer (TDA): A graphical tool for analyzing thread dumps.
Ø FastThread.io:
An online tool for analyzing thread dumps. Click http://fastthread.io
Ø JVisualVM:
Can visualize thread states and monitor CPU usage.
More Information’s bash:
- Run
your program in linux in jboss
- Goto
jboss or weblogic bin
- Search
your program running or not using below command
- ps
-ef | grep -applicationName
- Get
PID from linux after search
- Check
the cpu utilization using below any one command
- vmstat
1
- top
-p 123456 H, where 123456 is pid of this component
- Now
look into the command prompt and see the "id" column in command
prompt if it near to 100 then cpu ideal time is good
- Now
take the thread dump below command
- goto
folder location like: /opt/kcm folder
- using
cd
- using
like: /opt/kcm/softwares/jdk1.8.0_05/bin/jstack -l 20563 > log.txt
- where
20563 is pid in side jdk1.8.0_05 and log.txt is the thread dump file.
- Copy
this file from root folder from /opt/kcm/log.txt
- open
this file and see the log
- or
- open
this url http://fastthread.io
- upload
log.txt file
- see
the result
- Done
Conclusion
Analyzing thread dumps is a powerful method for diagnosing
performance issues in Java applications. By understanding thread states,
identifying blocked threads, and analyzing stack traces, you can pinpoint
issues such as deadlocks, thread contention, and CPU bottlenecks. Using tools
like jstack, jcmd, and various thread dump analyzers can significantly aid in
this process.
0 Comments