How to kill a thread in Java

In this comprehensive article, we delve into the crucial topic of terminating or how to kill a Java thread in a safe and efficient manner. It is imperative to grasp this concept as the conventional method for halting threads, namely Thread.stop(), Thread.suspend(), Thread.resume(), and Runtime.runFinalizersOnExit(), have been deprecated by Oracle due to inherent thread safety concerns.

To overcome this challenge, we present you with two recognized and widely embraced approaches that offer a cleaner alternative for terminating Java threads. By understanding and implementing these methods, you can ensure the proper handling and graceful termination of threads within your Java applications.

Let’s explore these two approaches that empower developers to effectively how to kill thread Java programming language.

How to kill a thread in java

Steps to Kill a Thread in Java

To terminate or kill a thread in Java or how to kill Java thread, you can follow a few steps :

  • Identify the thread you want to terminate: You need to have a reference to the specific thread you want to kill. This could be the thread itself or a reference to it in your code.
  • Use a shared flag or variable: Create a boolean flag or variable that will act as a signal for the thread to stop. This flag should be accessible from both the thread and the code controlling it.
  • Set the flag to indicate termination: When you want to terminate the thread, set the flag to the appropriate value (e.g., true) to signal that the thread should stop its execution.
  • Implement periodic checks in the thread: Inside the thread’s code, implement periodic checks of the flag or variable to see if it has been set to indicate termination. You can use conditional statements like if or while to perform these checks.
  • Gracefully exit the thread’s execution: When the flag is detected as indicating termination, perform necessary cleanup operations and exit the thread’s execution by returning from its run() method or any other means appropriate to your implementation.

It is important to note that directly “killing” or forcefully stopping a thread is not recommended, as it can lead to unpredictable behavior and resource leaks. It is generally considered better practice to provide a cooperative mechanism for the thread to gracefully terminate its execution when the appropriate conditions are met.

After this tutorial, we will know how to forcefully kill a thread in Java.

Kill a Java Thread using a flag

An effective method involves utilizing a thread to indicate the running state of a Thread, allowing for corrective actions to be taken based on specific requirements. Allow me to present you with a sample code that demonstrates how to terminate a Java Thread using a flag:

Example :

public class ThreadKiller {
    private static volatile boolean stopFlag = false;

    public static void main(String[] args) throws InterruptedException {
        Thread workerThread = new Thread(() -> {
            while (!stopFlag) {
                // Perform the thread's work here
                System.out.println("Worker thread is running...");
                try {
                } catch (InterruptedException e) {
            System.out.println("Worker thread has been terminated.");


        // Let the worker thread run for 5 seconds

        // Set the flag to true to stop the worker thread gracefully
        stopFlag = true;

        // Wait for the worker thread to complete

        System.out.println("Main thread exiting.");

Output :

Worker thread is running...Worker thread is running...Worker thread is running...Worker thread is running...
Worker thread is running...
Worker thread has been terminated.
Main thread exiting.

In this program, we create a stopFlag variable that acts as a flag to control the termination of the worker thread. The volatile keyword ensures that changes to the flag are visible to all threads.

The workerThread performs its work in a loop as long as the stopFlag is false. Inside the loop, you can place the actual logic or tasks that the thread needs to execute. In this example, it simply prints a message and sleeps for 1 second.

After the worker thread has run for 5 seconds, we set the stopFlag to true to indicate that the thread should stop executing. The worker thread will eventually notice the flag change and exit the loop.

We then call the join() method on the worker thread to wait for it to complete before the main thread exits.

By using a flag to control the termination of the thread. We can ensure a clean and controlled shutdown of the worker thread in Java.

Kill a Java Thread Using Interrupting a Thread

Example :

public class ThreadInterruptExample {
    public static void main(String[] args) {
        Thread myThread = new Thread(new MyRunnable());
        try {
            Thread.sleep(2000); // Allowing the thread to run for 2 seconds
        } catch (InterruptedException e) {
        myThread.interrupt(); // Interrupting the thread
        System.out.println("Main thread has finished.");

class MyRunnable implements Runnable {
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("Thread is running.");
            try {
                Thread.sleep(500); // Simulating some work being done
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // Restoring the interrupted status
                System.out.println("Thread has been interrupted while sleeping.");
        System.out.println("Thread has finished.");

Output :

Thread is running.
Thread is running.
Thread is running.
Thread is running.
Main thread has finished.
Thread has been interrupted while sleeping.
Thread has finished.

In this program, we create a separate thread (myThread) using the Runnable interface. The run() method in the MyRunnable class contains the code that will be executed by the thread. Inside the run() method, there is a while loop that continues until the thread is interrupted.

The Thread.currentThread().isInterrupted() method is used to check whether the thread has been interrupted. If it hasn’t, the thread continues running and performs its tasks. However, if the thread is interrupted using myThread.interrupt(), the isInterrupted() method will return true, and the while loop will exit.

When the thread is interrupted, an InterruptedException will be thrown while sleeping. In the catch block, we restore the interrupted status by calling theThread.currentThread().interrupt(), ensuring that the interrupted status is not lost.

Finally, the main thread sleeps for 2 seconds before interrupting myThread. Afterward, the main thread prints a message indicating that it has finished.

By interrupting the thread rather than forcefully stopping it. We adhere to a cleaner and safer approach for terminating Java threads.

Follow for More Info –

Discover Our Exciting Courses and Quiz

Enroll now to enhance your skills and knowledge!

Java Online Quiz

Level up your coding skills with our interactive programming quiz!