Get All Running JVM Threads

Last updated: January 8, 2024

Written by: baeldung

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Regression testing is an important step in the release process, to ensure that new code doesn't break the existing functionality. As the codebase evolves, we want to run these tests frequently to help catch any issues early on.

The best way to ensure these tests run frequently on an automated basis is, of course, to include them in the CI/CD pipeline. This way, the regression tests will execute automatically whenever we commit code to the repository.

In this tutorial, we'll see how to create regression tests using Selenium, and then include them in our pipeline using GitHub Actions:, to be run on the LambdaTest cloud grid:

>> How to Run Selenium Regression Tests With GitHub Actions

1. Overview

In this short tutorial, we’ll learn how to get all running threads in the current JVM, including the threads not started by our class.

2. Use the Thread Class

The getAllStackTrace() method of the Thread class gives a stack trace of all the running threads. It returns a Map whose keys are the Thread objects, so we can get the key set and simply loop over its elements to get information about the threads.

Let’s use the printf() method to make the output more readable:

Set<Thread> threads = Thread.getAllStackTraces().keySet();
System.out.printf("%-15s \t %-15s \t %-15s \t %s\n", "Name", "State", "Priority", "isDaemon");
for (Thread t : threads) {
    System.out.printf("%-15s \t %-15s \t %-15d \t %s\n", t.getName(), t.getState(), t.getPriority(), t.isDaemon());
}

The output will look like this:

Name            	 State           	 Priority        	 isDaemon
main            	 RUNNABLE        	 5               	 false
Signal Dispatcher 	 RUNNABLE        	 9               	 true
Finalizer       	 WAITING         	 8               	 true
Reference Handler 	 WAITING         	 10              	 true

As we see, besides thread main, which runs the main program, we have three other threads. This result may vary with different Java versions.

Let’s learn a bit more about these other threads:

Signal Dispatcher: this thread handles signals sent by the operating system to the JVM.
Finalizer: this thread performs finalizations for objects that no longer need to release system resources.
Reference Handler: this thread puts objects that are no longer needed into the queue to be processed by the Finalizer thread.

All these threads will be terminated if the main program exits.

3. Use the ThreadUtils Class from Apache Commons

We can also use the ThreadUtils class from Apache Commons Lang library to achieve the same goal:

Let’s add a dependency to our pom.xml file:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.14.0</version>
</dependency>

And simply use the getAllThreads() method to get all running threads:

System.out.printf("%-15s \t %-15s \t %-15s \t %s\n", "Name", "State", "Priority", "isDaemon");
for (Thread t : ThreadUtils.getAllThreads()) {
    System.out.printf("%-15s \t %-15s \t %-15d \t %s\n", t.getName(), t.getState(), t.getPriority(), t.isDaemon());
}

The output is the same as above.