Page History

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

A few Certain thread APIs were introduced to facilitate thread suspension, resumption, and termination but were later deprecated because of due to inherent design weaknesses. For example, the Thread.stop() method 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 could corrupt the state of the object potentially exposing the objects protected by those locks when those objects are in an inconsistent state. The thread could catch the {{ThreadDeath}} exception and use a {{finally}} block in an attempt to repair the inconsistent object or objects. However, 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 could result when executing {{catch}} or {{finally}} blocks \[[Sun 1999|AA. Bibliography#Sun 99]\]. Consequently, use of the {{Thread.stop()}} method is forbidden.

More information about deprecated methods is available in rule MET15-J. Do not use deprecated or obsolete classes or methods. Also, refer to rule ERR09-J. Do not allow untrusted code to terminate the JVM for information on preventing data corruption when the JVM is shut down abruptly.

...

Because the Vector class 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 2006|AA. Bibliography#API 06]\]. If the thread iswere in the process of adding a new integer to the vector when it iswas stopped, the vector maywould become accessible while it is in an inconsistent state. This cancould 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 request thread termination. 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 trueis set.

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 interrupt status flag. The thread polls that flag using the Thread.interrupted() method, which both returns true if the current thread has been interrupted and also clears the interrupt status flag.

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 (!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();
  }
}

A thread may use interruption for performing tasks other than cancellation and shutdown. Consequently, a thread should not be interrupted unless only when its interruption policy is known in advance. Failure to do so can result in failed interruption requests.

...

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 discouraged for trusted, custom-developed code that uses that method because the existing design presumably depends upon the ability of the system to perform this action. Furthermore, the system might not be designed fail to properly correctly handle the resulting exception. In these cases, it is preferable to programmers should implement an alternate design approach corresponding to another compliant solution one of the other compliant solutions described in this rule.

Risk Assessment

...

Automated Detection

TODO

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

...

...