How to Properly Stop a Java Thread: Methods, Examples, and Common Pitfalls

In Java, stopping a thread can be achieved in several ways, each with different safety implications. The article first introduces the concept of terminating a thread by allowing the run method to finish naturally using an exit flag.

It then describes three primary approaches:

Using an exit flag that causes the thread to exit after the run method completes.

Calling the deprecated stop method, which forcibly stops the thread but is unsafe and may leave shared resources in an inconsistent state.

Invoking interrupt , which sets the thread’s interrupt status and can be detected inside the thread.

To check a thread’s interrupt status, the article compares Thread.interrupted() (which clears the flag) with Thread.isInterrupted() (which does not clear the flag). Example code demonstrates how interrupted() returns false for the main thread because the interrupt was set on another thread.

When a thread is sleeping, calling interrupt() causes an InterruptedException to be thrown, and the interrupt status is cleared, as shown by the output of a sample program.

For more reliable termination, the article suggests throwing an exception from within the thread’s execution block and handling it in a catch clause, optionally re‑throwing to propagate the stop signal.

It also warns against using stop() because it can release locks abruptly, leading to data inconsistency, and explains that stop() throws a java.lang.ThreadDeath error, which is generally not caught.

Finally, the article demonstrates how combining interrupt() with a return statement can cleanly exit a thread’s loop, and provides a complete example of a thread that checks isInterrupted() and returns when the flag is set.

Key code snippets:

public class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 500000; i++) {
            if (this.interrupted()) {
                System.out.println("Thread stopped, exiting loop");
                break;
            }
            System.out.println("i=" + (i + 1));
        }
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new MyThread();
        thread.start();
        Thread.sleep(2000);
        thread.interrupt();
    }
}

These examples illustrate safe thread termination practices and the consequences of using deprecated methods.