Page History

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

Certain 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 throws causes the thread to immediately throw a ThreadDeath exception to stop , which usually stops the thread. Two cases arise:

...

More information about deprecated methods is available in MET02-J. Do not use deprecated or obsolete classes or methods.

Invoking Thread.stop() results in the release of all

...

locks

...

a thread has acquired,

...

potentially exposing the objects protected by those locks when those objects are in an inconsistent state

...

. The thread might catch the ThreadDeath exception and use a finally block in an attempt to repair the inconsistent object or objects. However, doing so requires careful inspection of all 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 might occur while executing catch or finally blocks [Sun 1999]. Consequently, programs must not invoke Thread.stop().

Removing the java.lang.RuntimePermission stopThread permission from the security policy file prevents threads from being stopped using the Thread.stop() method. Although this approach guarantees that the program cannot use the Thread.stop() method, it is nevertheless strongly discouraged. Existing trusted, custom-developed code that uses the Thread.stop() method presumably depends on the ability of the system to perform this action. Furthermore, the system might fail to correctly handle the resulting security exception. Additionally, third-party libraries may also depend on use of the Thread.stop() method.

Refer to ERR09-J. Do not allow untrusted code to terminate the JVM for information on preventing data corruption when the JVM is abruptly shut down

• As a remediation measure, catching the ThreadDeath exception on the other hand can itself ensnarl multithreaded code. For one, the exception can be thrown anywhere, making it difficult to trace and effectively recover from the exceptional condition. Also, there is nothing stopping a thread from throwing another ThreadDeath exception while recovery is in progress.

More information about deprecated methods is available in MET15-J. Do not use deprecated or obsolete methods.

Noncompliant Code Example (Deprecated Thread.stop())

This noncompliant code example shows a thread that fills a vector with pseudorandom numbers. The thread is forcefully stopped after a fixed 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 = 10vector.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 reflects returns the true correct number of elements in the vector even when an element is added or removed. This is , even after concurrent changes to the vector, because the vector instance uses its own intrinsic lock to prevent other threads from accessing it while its state is temporarily inconsistent.unmigrated-wiki-markup

However, the {{Thread.stop()}} method causes the thread to stop what it is doing and throw a {{ThreadDeath}} exception, and release all locks that it has acquired \[[API 06|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. For example, {{Vector.size()}} may be two while the vector contains three elements (the element count is incremented after adding the element) exception. All acquired locks are subsequently released [API 2014]. If the thread were in the process of adding a new integer to the vector when it was stopped, the vector would become accessible while it is in an inconsistent state. For example, this could result in Vector.size() returning an incorrect element count because the element count is incremented after adding the element.

Compliant Solution (volatile flag)

This compliant solution stops the thread by using uses a volatile flag . An accessor method to 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 shuts down 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 = 10vector.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();
  }
}

Compliant Solution (Interruptible)

This In this compliant solution stops the thread by , 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 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 = 10vector.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();
  }
}

This method interrupts the current thread, however, it only stops the thread because the thread logic polls the interrupted flag using the method Thread.interrupted(), and shuts down when it is interrupted.

Compliant Solution (RuntimePermission stopThread)

Remove the default permission java.lang.RuntimePermission stopThread from the security policy file to deny the Thread.stop() invoking code, the required privileges.

Noncompliant Code Example (blocking IO, volatile flag)

This noncompliant code example uses a volatile done flag to indicate when the thread should shut down, as suggested above. However, this does not help in terminating the thread because it is blocked on some network IO as a consequence of using the readLine() method.

class SocketReader implements Runnable {
  private final Socket socket;
  private final BufferedReader in;
  private volatile boolean done = false;
  private final Object lock = new Object();
  private boolean isRunning = false;
  public static class MultipleUseException extends RuntimeException {};

  public SocketReader() throws IOException {
    this.socket = new Socket("somehost", 25);
    this.in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
  }
  
  // Only one thread can use the socket at a particular time
  public void run() {
    try {
      synchronized (lock) {
        if (isRunning) {
          throw new MultipleUseException();
        }
        isRunning = true;
      }
      execute();
    } catch (IOException ie) {
      // Forward to handler
    }
  }

  public void execute() throws IOException {
    String string;
    while (!done && (string = in.readLine()) != null) {
      // Blocks until end of stream (null)
    }
  }

  public void shutdown() {
    done = true;
  }

  public static void main(String[] args) throws IOException, InterruptedException {
    SocketReader reader = new SocketReader();
    Thread thread = new Thread(reader);
    thread.start();
    Thread.sleep(1000);
    reader.shutdown();
  }
}

Note that the Runnable object prevents itself from being run in multiple threads using an isRunning() flag. If one thread tries to invoke run() after another thread has already done so, the method will exit with an exception. This exception is not recoverable, as it indicates a bug in the proper usage of this class, and hence, it may be unchecked.

Noncompliant Code Example (blocking IO, interruptible)

This noncompliant code example uses thread interruption to indicate when the thread should shut down, as suggested above. However, this does not help in terminating the thread because it is blocked on some network IO as a consequence of using the readLine() method. Network I/O is not responsive to thread interruption.

class SocketReader implements Runnable {
  // ...
  
  public void execute() throws IOException {
    String string;
    while (!Thread.interrupted() && (string = in.readLine()) != null) { 
      // Blocks until end of stream (null)
    }
  }
  
  public static void main(String[] args) throws IOException, InterruptedException {
    SocketReader reader = new SocketReader();
    Thread thread = new Thread(reader);
    thread.start();
    Thread.sleep(1000); 
    thread.interrupt();
  }
}

Compliant Solution (close socket connection)

This compliant solution closes the socket connection, by having the shutdown() method close the socket. As a result, the thread is bound to stop because of a SocketException. Note that there is no way to keep the connection alive if the thread is to be cleanly halted immediately.

class SocketReader implements Runnable {
  // ...
  
  public void execute() throws IOException {
    String string;
    try {
      while ((string = in.readLine()) != null) { 
        // Blocks until end of stream (null)
      }
    } finally {
      shutdown();
    }
  }
  
  public void shutdown() throws IOException {
    socket.close();
  }

  public static void main(String[] args) throws IOException, InterruptedException {
    SocketReader reader = new SocketReader();
    Thread thread = new Thread(reader);
    thread.start();
    Thread.sleep(1000); 
    reader.shutdown();
  }
}

A boolean flag can be used (as described earlier) if additional clean-up operations need to be performed.

Compliant Solution (interruptible channel)

This compliant solution uses an interruptible channel, SocketChannel instead of a Socket connection. If the thread performing the network IO is interrupted using the Thread.interrupt() method, for instance, while reading the data, the thread receives a ClosedByInterruptException and the channel is closed immediately. The thread's interrupt status is also set.

class SocketReader implements Runnable {
  private final SocketChannel sc;
  private final Object lock = new Object();
  private boolean isRunning = false;
  private class MultipleUseException extends RuntimeException {};
  
  public SocketReader() throws IOException {
    sc = SocketChannel.open(new InetSocketAddress("somehost", 25));    
  }
  
  public void run() {
    synchronized (lock) {
      if (isRunning) {
        throw new MultipleUseException();
      }
      isRunning = true;
    }

    ByteBuffer buf = ByteBuffer.allocate(1024);
    try {
      synchronized (lock) {
        while (!Thread.interrupted()) {
          sc.read(buf);
          // ...
        }
      }
    } catch (IOException ie) {
      // Forward to handler
    }
  }

  public static void main(String[] args) throws IOException, InterruptedException {
    SocketReader reader = new SocketReader();
    Thread thread = new Thread(reader);
    thread.start();
    Thread.sleep(1000);
    thread.interrupt();
  }
}

This method interrupts the current thread, however, it only stops the thread because the thread logic polls the interrupted flag using the method Thread.interrupted(), and shuts down when it is interrupted.

Noncompliant Code Example (Socket per thread)

This noncompliant code example shows a thread-safe variant of the SocketReader class that creates a Socket per thread, that is, the socket is not shared amongst multiple threads. This is a common scenario in applications that must place requests to several servers simultaneously, without using any locking.

// Thread-safe SocketReader
public class SocketReader implements Runnable {
  private final String host;
  private final int port;

  SocketReader(String host, int port) {
    this.host = host;
    this.port = port;
  }

  public void run() {
    Socket socket = null;
    try {
      socket = new Socket(host, port);
    } catch (UnknownHostException e) {
      // Forward to handler	
    } catch (IOException e) {
      // Forward to handler
    }
    // Do some useful work
  }
}

This design does not permit a client to close the socket when a thread is blocked, or is performing some time consuming activity.

Compliant Solution (ThreadLocal)

This compliant solution uses a ThreadLocal wrapper around the socket so that a thread that calls initialValue() obtains a unique socket instance. The advantage of this approach is that a shutdownSocket() method can be provided so that clients external to the class can also shutdown the socket when it is blocked, or is performing some time consuming activity.

class SocketReader implements Runnable {
  private static ThreadLocal<Socket> connectionHolder = new ThreadLocal<Socket>() {
    Socket socket = null;
    @Override public Socket initialValue() {		
      try {
        socket = new Socket("defaultHost", 25); // 25 is the default port to connect to
      } catch (UnknownHostException e) {
        // Forward to handler	
      } catch (IOException e) {
        // Forward to handler
      }
      return socket;
    }
	
    @Override public void set(Socket sock) {
      if(sock == null) { // Shuts down socket when null value is passed 	
        try {
  	  socket.close();
        } catch (IOException e) {
 	  // Forward to handler	
        }
      } else {
        socket = sock; // Assigns Socket with caller specified hostname and port
      }
    }
  };

  public static Socket getSocketConnection() {
    return connectionHolder.get();
  }

  public static void shutdownSocket() { // Allows client to close socket anytime
    connectionHolder.set(null);
  }

  public void run() {
    Socket socket = getSocketConnection();
    // Do some useful work
  }
}

Risk Assessment

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

Risk Assessment

Forcing a thread to stop can result in inconsistent object state. Critical resources could Trying to force thread shutdown can result in inconsistent object state and corrupt the object. Critical resources may also leak if cleanup operations are not carried out as required.

Automated Detection

...

Tool	Version	Checker	Description
Parasoft Jtest	Include Page Parasoft_V Parasoft_V	CERT.THI05.THRD	Avoid calling unsafe deprecated methods of 'Thread' and 'Runtime'

Related Guidelines

Android Implementation Details

On Android, Thread.stop() was deprecated in API level 1.

Bibliography

...

Image Added Image Added Image Added

TODO

Related Vulnerabilities

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

References

\[[API 06|AA. Java References#API 06]\] Class Thread, method {{stop}}
\[[Darwin 04|AA. Java References#Darwin 04]\] 24.3 Stopping a Thread
\[[JDK7 08|AA. Java References#JDK7 08]\] Concurrency Utilities, More information: Java Thread Primitive Deprecation 
\[[JPL 06|AA. Java References#JPL 06]\] 14.12.1. Don't stop and 23.3.3. Shutdown Strategies
\[[JavaThreads 04|AA. Java References#JavaThreads 04]\] 2.4 Two Approaches to Stopping a Thread

CON12-J. Avoid deadlock by requesting and releasing locks in the same order      11. Concurrency (CON)      VOID CON14-J. Ensure atomicity of 64-bit operations