Page History

Threads always preserve class invariants when they are allowed to exit normally. Programmers often try to abruptly terminate threads abruptly when they believe that the task is accomplished, the request has been canceled, or the program or JVM needs to quickly shut down.

A few thread APIs were introduced to facilitate thread suspension, resumption, and termination but were later deprecated because of inherent design weaknesses. The For example, the Thread.stop() method is one example. It causes the thread to immediately throw a ThreadDeath exception, which usually stops the thread.

Invoking {{Thread.stop()}} results in the release of all the locks a thread has acquired, which may corrupt the state of the object. The thread could catch the {{ThreadDeath}} exception and use a {{finally}} block in an attempt to repair the inconsistent object,. howeverHowever, this requires careful inspection of all the synchronized methods and blocks because a {{ThreadDeath}} exception can be thrown at any point during the thread's execution. Furthermore, code must be protected from {{ThreadDeath}} exceptions that may result when executing {{catch}} or {{finally}} blocks \[[Sun 991999|AA. Java References#Sun 99]\].

More information about deprecated methods is available in guideline MET15-J. Do not use deprecated or obsolete methods. Also, refer to guideline EXC09-J. Prevent inadvertent calls to System.exit() or forced shutdown for information on preventing data corruption when the JVM is abruptly shut down abruptly.

Noncompliant Code Example (Deprecated Thread.stop())

This noncompliant code example shows a thread that fills a vector with pseudorandom pseudo-random numbers. The thread is forcefully stopped after a given amount of time.

public final class Container implements Runnable {
  private final Vector<Integer> vector = new Vector<Integer>(1000);

  public Vector<Integer> getVector() {
    return vector;
  }

  @Override public synchronized void run() {
    Random number = new Random(123L);
    int i = vector.capacity();
    while (i > 0) {
      vector.add(number.nextInt(100));
      i--;
    }
  }

  public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new Container());
    thread.start();
    Thread.sleep(5000);
    thread.stop();
  }
}

Because the Vector class Vector is thread-safe, operations performed by multiple threads on its shared instance are expected to leave it in a consistent state. For instance, the Vector.size() method always returns the correct number of elements in the vector even in the face of concurrent changes to the vector. This is because the vector instance uses its own intrinsic lock to prevent other threads from accessing it while its state is temporarily inconsistent.

However, the {{Thread.stop()}} method causes the thread to stop what it is doing and throw a {{ThreadDeath}} exception. All acquired locks are subsequently released \[[API 062006|AA. Java References#API 06]\]. If the thread is in the process of adding a new integer to the vector when it is stopped, the vector may become accessible while it is in an inconsistent state. This can result in {{Vector.size()}} returning an incorrect element count, for example, because the element count is incremented after adding the element.

...

This compliant solution uses a volatile flag to terminate the thread. An accessor method The shutdown() accessor method is used to set the flag to true. The thread's run() method polls the done flag , and terminates when it becomes true.

public final class Container implements Runnable {
  private final Vector<Integer> vector = new Vector<Integer>(1000);
  private volatile boolean done = false;

  public Vector<Integer> getVector() {
    return vector;
  }

  public void shutdown() {
    done = true;
  }

  @Override public synchronized void run() {
    Random number = new Random(123L);
    int i = vector.capacity();
    while (!done && i > 0) {
      vector.add(number.nextInt(100));
      i--;
    }
  }

  public static void main(String[] args) throws InterruptedException {
    Container container = new Container();
    Thread thread = new Thread(container);
    thread.start();
    Thread.sleep(5000);
    container.shutdown();
  }
}

...

In this compliant solution, the Thread.interrupt() method is called from main() to terminate the thread. Invoking Thread.interrupt() sets an internal flag known as the interrupt status flag. The thread polls the interrupt status that flag using the Thread.interrupted() method, which returns true if the current thread has been interrupted and clears the interrupt status.

public class Container implements Runnable {
  private final Vector<Integer> vector = new Vector<Integer>(1000);

  public Vector<Integer> getVector() {
    return vector;
  }

  @Override public synchronized void run() {
    Random number = new Random(123L);
    int i = vector.capacity();
    while (!Thread.interrupted() && i > 0) {
      vector.add(number.nextInt(100));
      i--;
    }
  }

  public static void main(String[] args) throws InterruptedException {
    Container c = new Container();
    Thread thread = new Thread(c);
    thread.start();
    Thread.sleep(5000);
    thread.interrupt();
  }
}

...

Removing the default permission java.lang.RuntimePermission stopThread permission from the security policy file prevents threads from being stopped using the Thread.stop() method. This approach is not recommended for trusted, custom-developed code that uses the Thread.stop() as that method because the existing design presumably depends upon the ability of the system to perform this action. Furthermore, the system may not be designed to properly handle the resulting exception. In these cases, it is preferable to implement an alternate design approach corresponding to one of other another compliant solutions described in this guideline.

...

Forcing a thread to stop can result in inconsistent object state. Critical resources may also leak if clean-up operations are not carried out as required.

Automated Detection

TODO

Related Vulnerabilities

...

References

\[[API 062006|AA. Java References#API 06]\] Class Thread, method {{stop}}, interface ExecutorService
\[[Sun 991999|AA. Java References#Sun 99]\]
\[[Darwin 042004|AA. Java References#Darwin 04]\] 24.3 Stopping a Thread
\[[JDK7 082008|AA. Java References#JDK7 08]\] Concurrency Utilities, More information: Java Thread Primitive Deprecation
\[[JPL 062006|AA. Java References#JPL 06]\] 14.12.1. Don't stop and 23.3.3. Shutdown Strategies
\[[JavaThreads 042004|AA. Java References#JavaThreads 04]\] 2.4 Two Approaches to Stopping a Thread
\[[Goetz 062006|AA. Java References#Goetz 06]\] Chapter 7: Cancellation and shutdown

...