Stopping Java Threads: interrupt, volatile flag, and combined approaches

1. Interrupt Mechanism

Principle

The interrupt mechanism is a cooperative way to stop a thread in Java. Calling interrupt() sets the thread's interrupt flag; the thread should periodically check this flag and decide how to stop. If the thread is blocked in methods such as sleep() or wait() , an InterruptedException is thrown, allowing the thread to handle the interruption.

Example Code

public class InterruptThread implements Runnable {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted() && moreWorkToDo) {
            // business logic
            System.out.println("线程正在运行...");
            try {
                Thread.sleep(1000); // simulate time‑consuming operation
            } catch (InterruptedException e) {
                // optionally restore the interrupt status
                Thread.currentThread().interrupt();
            }
        }
        System.out.println("线程已中断，准备停止...");
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new InterruptThread());
        thread.start();
        Thread.sleep(3000); // main thread sleeps 3 seconds
        thread.interrupt(); // send interrupt request
    }
}

Advantages

High safety : does not forcefully terminate the thread, allowing it to clean up resources and avoid data inconsistency.

Timely response : a blocked thread can still detect the interrupt via InterruptedException .

Disadvantages

Requires thread cooperation : the thread must check the interrupt flag or handle InterruptedException ; otherwise it may not stop.

2. Volatile Flag

Principle

A volatile boolean variable is used as a flag. When the flag is set to true , the running thread periodically checks the flag and stops when it sees the change.

Example Code

public class VolatileThread implements Runnable {
    private volatile boolean canceled = false; // volatile flag

    @Override
    public void run() {
        int count = 0;
        while (!canceled) {
            System.out.println("count = " + count++);
            try {
                Thread.sleep(500); // simulate time‑consuming operation
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("线程已停止...");
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileThread vt = new VolatileThread();
        Thread thread = new Thread(vt);
        thread.start();
        Thread.sleep(3000); // main thread sleeps 3 seconds
        vt.canceled = true; // set flag to true to notify thread to stop
    }
}

Advantages

Simple implementation : easy to understand and suitable for simple stop scenarios.

Disadvantages

Cannot respond while blocked : if the thread is waiting on a lock or I/O, the flag change is not detected promptly.

No exception handling : unlike the interrupt mechanism, there is no InterruptedException to signal the need for cleanup.

3. Combined Interrupt + Volatile Flag

Principle

This approach merges both techniques: the interrupt mechanism handles blocked states, while the volatile flag allows quick checks in non‑blocked states, providing reliable termination in all situations.

Example Code

public class InterruptAndVolatileThread implements Runnable {
    private volatile boolean canceled = false; // volatile flag

    @Override
    public void run() {
        while (!canceled && !Thread.currentThread().isInterrupted() && moreWorkToDo) {
            System.out.println("线程正在运行...");
            try {
                Thread.sleep(1000); // simulate time‑consuming operation
            } catch (InterruptedException e) {
                // restore interrupt status
                Thread.currentThread().interrupt();
                // also set the volatile flag
                canceled = true;
            }
        }
        System.out.println("线程已停止...");
    }

    public static void main(String[] args) throws InterruptedException {
        InterruptAndVolatileThread iavt = new InterruptAndVolatileThread();
        Thread thread = new Thread(iavt);
        thread.start();
        Thread.sleep(2000); // main thread sleeps 2 seconds
        // stop thread using interrupt (or set iavt.canceled = true)
        thread.interrupt();
    }
}

Advantages

High reliability : works whether the thread is blocked or running normally.

Good flexibility : developers can choose to interrupt or set the flag based on the scenario.

Disadvantages

Slightly more complex : requires handling both interrupt status and the volatile flag.

4. Summary

In Java, stopping a thread can be achieved via three main schemes, each with its own pros and cons:

Scheme

Advantages

Disadvantages

Interrupt mechanism

High safety, timely response

Depends on thread cooperation and exception handling

Volatile flag

Simple implementation

Cannot respond while blocked; no exception mechanism

Interrupt + volatile flag

High reliability, good flexibility

Implementation is a bit more complex

For most real‑world projects, it is recommended to prefer the interrupt mechanism because it provides a safer and more reliable way to stop threads. If the stopping requirement is simple and the thread does not spend long periods in a blocked state, a volatile flag can be considered.