Is there a good way to forcefully stop a Java thread?

Question

I want to stop a Java thread immediately but when I try the thread always takes some time before stopping. Is there a good way to force a Java thread to stop instantly?

Answer 1

There is no good way to stop a thread instantly.

• There is Thread.stop(), but it is dangerous and deprecated. Don't use it, unless:

  1. you fully understand the problems that make it dangerous,

  2. you have thoroughly analyzed your code and determined that the problems do not apply and / or the risks are acceptable, and

  3. you don't care that your application may end up stuck at a some version of Java if / when the method is removed¹.

• There was Thread.stop(Throwable) but it was equally dangerous², deprecated and was removed³ in Java 11.

• There is Thread.interrupt(), but there is no guarantee that the thread will stop quickly, or even stop at all. The behavior will depend on whether the application thread code has been designed to notice and correctly respond to interrupts. (See below.)

• There is the approach of writing the thread to periodically check a flag; see this answer. (See below.)

---

The "check a flag" and interrupt() approaches are largely the same. In both cases, the thread that expects to be interrupted needs to regularly check; e.g. by calling interrupted() or isInterrupted() or by checking a flag.

The difference between the approaches is that that the interrupt() mechanism will work when the code is waiting for a notify(), join(), etcetera, or blocked in an I/O operation. Because of this, and because interrupt is an accepted application independent way of doing this, it is usually preferable to implementing an application specific flag mechanism.

---

^{1 - In the Java 18 prerelease javadocs, Thread.stop() is now shown as "flagged for removal".
2 - Possibly more so. If you did a Thread.stop(new IOException()) for example, some code further up the call stack could easily catch the exception and subvert your "stop".
3 - You can still use the old "stop with an exception" functionality by calling the private Thread.stop0(Throwable) method reflectively; see https://stackoverflow.com/a/67077495/139985. It would be better to avoid having to do that.}

Answer 2

There is one good way to safely (and quickly) force stop a thread:

System.exit(0)

Unfortunately, this has the side effect of killing all other threads.

Answer 3

Running Thread cannot be stopped using Thread.Interrupt , only waiting or blocking threads can be stopped using Thread.Interrupt.But using a shared variable to signal that it should stop what it is doing. The thread should check the variable periodically,(ex : use a while loop ) and exit in an orderly manner.

private boolean isExit= false;

public void beforeExit() {
    isExit= true;
}

public void run() {
    while (!isExit) {

    }
}

Answer 4

Do not under any circumstances use Thread.stop - if you are asking this question then you do not understand the Java threading model enough to safely use it.

The details, for the curious, are here: Java Thread Primitive Deprecation

If you get really good at Java concurrency, then you will understand why you should never use it, and that even if it's entirely safe within your own code, it makes your code contaminated and unusable by anyone else. Instead you will probably end up use the boolean variable trick or some other pattern to tell a thread when it should finish up and then exit.

Do not use Thread.stop. Ever.

Answer 5

You can still stop a thread with a specific exception even in later versions of the JDK.

You need to use reflection since the stop(Throwable) has been removed but the underlying native method stop0(Throwable) (which is also called by stop()) is still there, though not visible.

Here is a simple method that can be used to actively stop a thread by throwing a given exception.

public static boolean stopWith(Thread t, Throwable e){
    try {
        Method m = Thread.class.getDeclaredMethod("stop0", Object.class);
        m.setAccessible(true);
        m.invoke(t, e);
        m.setAccessible(false);
        return true;
    } catch (Exception e1) {
        e1.printStackTrace();
    }
    return false;
}

This works as of JDK 11 but is is represents and illegal reflective access.

If your code uses modules, by default your module is not allowed to access non public members through reflection (because java.base/java.lang is not open to other modules). Therefore an java.lang.reflect.InaccessibleObjectException is thrown. It is possible to override the default opening of the java.base/ module using the --add-opens flag of the JVM, e.g. --add-opens java.base/java.lang=your.module.

If your code is not using modules (i.e. Java 8 or previous), since for backward compatibility java.base/ is open to all unnamed modules (ALL-UNNAMED) no exception is thrown. But a non avoidable warning message is logged:

WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by YourCalss (file:/path/to/your/class/) to method java.lang.Thread.stop0(java.lang.Object)
WARNING: Please consider reporting this to the maintainers of TestSop
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release

Answer 6

Your thread could be put in a while loop and check a boolean variable each time through. When you set the variable to false the loop would end and so would the thread. To end the thread before going through the current loop you can use the break keyword.

This avoids using deprecated methods such as Thread.stop().

private volatile boolean run = true;   // Needs be volatile ... or changes may
                                       // not be visible to all threads.

//Call this method to end your thread
void stopRunning(){
    run = false;
}

//This loop would go into the overided run() method

while(run){
    //Put your task here
}

The thread will finish the current task and then stop itself naturally.

If you need the thread to stop before finishing the task, you can check the run variable using an if/else anywhere in the loop and end the thread just like anywhere else.

while(run){
    //Your code here

    /*Be sure your not stopping the task at a point that will harm your program.*/
    if(!run){break;}
}

Answer 7

In any and every language, you must never write code that depends on the execution pattern nor the timing of any other process or thread. You may send a signal asking for a thread to stop itself, or you may forcibly terminate it, but you still cannot predict exactly when the dirty deed will be done. You must carefully write code that is immune to so-called "race conditions."