Mastering Thread Termination in Java: Safe Practices and Common Pitfalls

1. Ways to Stop a Thread

Stopping a thread means abandoning its current operation before the task finishes. The deprecated Thread.stop() can stop a running thread but is unsafe and should not be used.

Java provides three safer ways to terminate a thread:

Use an exit flag so the thread exits normally when run() completes.

Avoid stop() because it is deprecated along with suspend() and resume().

Call interrupt() to signal interruption.

2. Checking Thread Interruption State

The Thread class offers two methods: Thread.interrupted() – tests whether the current thread has been interrupted and clears the flag. Thread.isInterrupted() – tests the interruption status without clearing it.

Example code shows that calling thread.interrupt() and then printing thread.interrupted() from the main thread yields false because the flag is cleared after the first call.

3. Stoppable Thread – Exception Method

By checking this.interrupted() inside a loop, you can break out of the loop when the thread is interrupted. Throwing an InterruptedException from the loop allows the catch block to handle cleanup and stop further execution.

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

4. Stopping While Sleeping

If a thread is in Thread.sleep() and receives an interrupt, it throws InterruptedException. The exception clears the interrupt status, so isInterrupted() returns false inside the catch block.

public class MyThread extends Thread {
    public void run() {
        try {
            System.out.println("Thread starts...");
            Thread.sleep(200000);
            System.out.println("Thread ends.");
        } catch (InterruptedException e) {
            System.out.println("Interrupted while sleeping, isInterrupted=" + this.isInterrupted());
            e.printStackTrace();
        }
    }
}

5. Violent Stop with stop()

The stop() method terminates a thread abruptly, which can leave shared resources in an inconsistent state. Example code shows a thread printing numbers until stop() is called, after which the program exits.

public class MyThread extends Thread {
    public void run() {
        int i = 0;
        while (true) {
            System.out.println("i=" + i);
            i++;
            Thread.sleep(200);
        }
    }
}

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

6. stop() and ThreadDeath Exception

Calling stop() throws a ThreadDeath error, which usually does not need to be caught. However, catching it can reveal that the thread was forcefully terminated.

7. Bad Consequences of Releasing Locks

Using stop() while a thread holds a lock can release the lock without completing critical sections, leading to data inconsistency. Example demonstrates a synchronized method that is interrupted mid‑execution, leaving object fields partially updated.

8. Stopping Thread with return

Combining interrupt() with a check inside the loop and a return statement provides a clean way to stop a thread. The thread exits the run() method gracefully after printing a termination message.

public class MyThread extends Thread {
    public void run() {
        while (true) {
            if (this.isInterrupted()) {
                System.out.println("Thread stopped!");
                return;
            }
            System.out.println("Time: " + System.currentTimeMillis());
        }
    }
}