Updated April 15, 2023
Introduction to Java thread dump
The java thread dump is defined as the dump of all the live processing threads in the stack memory; it can be a vital role in the artifacts for to diagnose the CPU usages like spikes, deadlocks, memory problems, unresponsive applications with some default error codes sooor request and response times and even though some other system related issues also calculated and related to the thread dump messages based on the application server it will be configured to the server-config files mainly it recommended for more than 1 thread dump and at least 10 dump threads used at the regular intervals in the JVM.
Syntax
If we use java programming language, it can have default classes and methods used for creating the web applications more sophisticated. Here the thread dump will be analyzed using the tools here; the basic syntax for the java thread dumps are as follows.
class className
{
public static void main(String[] args) throws Exception
{
Object o = new Object();
Object o1= new Object();
Thread t=new Thread(new DeadLockRunnable(o,o1));
t.sleep();
--some java code logics---
}
}The above codes are the basic syntax for creating the thread dump in the stack memory with the help of concepts like deadlock etc. In addition, we can use some default methods like DeadLockRunnable, ManagementFactory.getThreadMXBean(); these are some methods to achieving the thread dump in the programming stack.
How does thread dump work in Java?
In Java applications, we have used the web servers and application servers for running the applications in both browsers and desktop(if it is in standalone application). Due to the web servers we have used for accessing tens to hundreds of the threads to process in a large number of concurrent users. If suppose the application will be accessed for more than one user, i.e.) two or more users accessed at the same time the same resources, the contention between the two threads is inevitable, and even sometimes the deadlock will occur. Based on the webserver, the thread dump will be configured like for example; Apache tomcat will configure the thread dump using an option like <TOMCAT_HOME>/logs/Catalina.out the file if we open the config file, we will be configured the out java codes if it’s there in the multi-threading concepts involved in the application the server throws the errors and exceptions in the stack trace.
The thread dump has different states for showing whether the application user is alive or not else Keep- Alive-Timer is also a thread name; this should be used for creating the KeepAliveCache thread, which has been in order for a living http thread. Each and every thread created by using the JVM since it has been started after the thread-like daemon, which means that it won’t be able to prevent the JVM from the last running thread from shutting down in both machine and applications.
Some most important thread states like Runnable, Waiting/Timed_waiting and Blocked these are some states which are going to be the used for blocking and waiting for the threads if the application or process is in multi-threading so whenever the thread is created is automatic goes to the Runnable interface after that several metadata related about the thread’s priority including os thread priority if the thread us running the thread is runnable mode blocking state is used for to block the threads if the apps are in multi-threading after completion of the one thread the other thread is performed until that it has been locked state so with the help of concepts like synchronized thread blocks, etc. using these concepts and their instance it has been achieved. The waiting status is the thread waiting time is calculated, and it has been stored in the thread memory called thread pool it has been waiting for to be work in these states.
Examples of Java thread dump
Different examples are mentioned below:
Example #1
Code:
package com.first;
import java.net.ServerSocket;
import java.net.Socket;
public class Example {
public void run()
{
System.out.println("Multithreads names are : " + Thread.currentThread().getName());
}
public static void main(String[] args) throws Exception {
long waitingtimethread = 2000 * 30 * 2;
long startingthread = System.currentTimeMillis();
Thread t = new Thread();
t.start();
Thread.sleep(300);
t.run();
try (
ServerSocket s = new ServerSocket(3000);
Socket s1 = s.accept()
) {
Thread t1 = new Thread();
t1.start();
while (t1.isAlive()) {
if (demo(startingthread, waitingtimethread, t1)) {
t1.interrupt();
t1.join();
}
}
} catch (Exception e) {
System.err.println("The Excetion will be captured here."+e);
}
System.out.println("Multithreads names are : " + Thread.currentThread().getName());
System.out.println("We can check the daemon thread is used or not: "
+ Thread.currentThread().isDaemon());
}
static boolean demo(long startingthread, long waitingtimethread, Thread t1) {
return ((System.currentTimeMillis() - startingthread) > waitingtimethread) && t1.isAlive();
}
}Output:
Example #2
Code:
package com.first;
import java.net.ServerSocket;
import java.net.Socket;
public class Example {
static boolean demo(long startingthread, long waitingtimethread, Thread t1) {
return ((System.currentTimeMillis() - startingthread) > waitingtimethread) && t1.isAlive();
}
public static void main(String[] args) throws Exception {
long waitingtimethread = 2000 * 30 * 2;
long startingthread = System.currentTimeMillis();
Thread t = new Thread();
Thread t2 = new Thread();
t.start();
Thread.sleep(300);
t.run();
try (
ServerSocket s = new ServerSocket(3000);
Socket s1 = s.accept()
) {
Thread t1 = new Thread();
t1.start();
while (t1.isAlive()) {
if (demo(startingthread, waitingtimethread, t1)) {
t1.interrupt();
t1.join();
t1.notifyAll();
t2.notify();
}
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("Multithreads names are : " + Thread.currentThread().getName());
}
}Output:
Example #3
Code:
package com.first;
public class Example extends Thread {
public void run()
{
System.out.println("Multithreads names are : " + Thread.currentThread().getName());
System.out.println("We can check the daemon thread is used or not: "
+ Thread.currentThread().isDaemon());
}
public static void main(String[] args)
{
Example e1 = new Example();
Example e2 = new Example();
e1.start();
e1.setDaemon(true);
e2.start();
}
}Output:
In the above three examples, we used different scenarios for the thread dump concepts; also, we used different types of built-in thread methods like notify(), Timed_Waiting(), sleep(); these concurrent static methods will achieve the dump of multiple threads in the java.
Conclusion
Generally, thread dumps are some useful mechanism for java-based web applications for getting the detailed analyzed reports. It includes multiple users accessing the application directly or indirectly; these process will be helpful for solving the interruptions and increasing the performance of the applications.
Recommended Articles
This is a guide to the Java thread dump. Here we discuss How does thread dump work in Java and Examples along with the codes and outputs. You may also have a look at the following articles to learn more –
