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 due to 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.

...

Noncompliant Code Example (Deprecated

Thread.stop())

This noncompliant code example shows a thread that forcefully comes to a halt when the Thread.stop() method is invoked. Neither the catch nor the finally block executes. Any monitors that are held are immediately released, leaving the object in a delicate statefills a vector with pseudorandom numbers. The thread is forcefully stopped after a given amount of time.

public final class BadStopContainer implements Runnable {
  publicprivate voidfinal run() {
    try {
      Thread.currentThread().sleepVector<Integer> vector = new Vector<Integer>(1000);

  public Vector<Integer> } catch(InterruptedException iegetVector() {
 //  Not executedreturn vector;
  }

  @Override public synchronized void System.out.println("Performing cleanup"); run() {
    }Random finallynumber {= // Not executednew Random(123L);
    int i =  System.out.println("Closing resources"vector.capacity(); 
    }while (i > 0) {
   
    System.out.println("Done!"vector.add(number.nextInt(100));
      }
i--;
    }

class Controller {}

  public static void main(String[] args) throws InterruptedException {
    Thread tthread = new Thread(new BadStopContainer());
    tthread.start();  
    tThread.interruptsleep(5000); // Artificially induce an InterruptedException
    tthread.stop();      // Force thread cancellation
  }
}

The {{Thread.interrupt()}} method is frequently used to awaken a blocked thread before it can be stopped. It awakens threads that are blocked on {{wait()}} methods of class {{Object}}, and {{join}} and {{sleep}} methods of class {{Thread}}. In these cases, the thread's interrupt status is cleared and it receives an {{InterruptedException}}. If the thread is blocked on I/O operations upon an interruptible channel, the channel is closed, the thread's interrupt status is set and it receives a {{ClosedByInterruptException}}. Similarly, a thread waiting on a selector also returns from the operation with its interrupted status set. \[[API 06|AA. Java References#API 06]\]   

The java.lang.ThreadGroup.interrupt() is not deprecated and is often seen as an option to interrupt all the threads belonging to a thread group. "This is no guarantee that a program will terminate, however, because libraries that you have used may have created user threads that do not respond to interrupt requests. The AWT graphics library is one well-known example.". Moreover, using the ThreadGroup API is discouraged (see CON17-J. Avoid using ThreadGroup APIs).

Compliant Solution (1) (volatile flag)

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 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.

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 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 uses a volatile flag to request thread termination. The shutdown() accessor method This compliant example uses a boolean flag called done to indicate whether the thread should be stopped after any necessary cleanup code has finished executing. An accessor method shutdown() is used to set the flag to true, after which the thread can start the cancellation process. The done flag is also set immediately after the execution of the finally block's resource clean-up statements so that the system does not continue relinquishing resources that it has already released, in the event of the done flag staying false. The thread's run() method polls the done flag and terminates when it is set.

public final class ControlledStopContainer implements Runnable {
  protectedprivate volatilefinal booleanVector<Integer> donevector = false;
  public void run() {
    while(!done) {
      try {
        Thread.currentThread().sleep(new Vector<Integer>(1000);
  private volatile   } catch(InterruptedException ie) { 
          System.out.println("Interrupted Exception");
          // Handle the exception 
      } finally { 
          System.out.println("Closing resources");  
          boolean done = true;
      }
    } false;

  public  done = false; // Reset for later use
    System.out.println("Done!");
  }

  protected void shutdown()Vector<Integer> getVector() {
    donereturn = truevector;
  }
}

class Controller {
  public static void mainshutdown(String[] args) throws InterruptedException {  
    ControlledStop cdone = new ControlledStop()true;
    Thread t = new Thread(c);
    t.start();
    t.interrupt();       // Artificially induce an InterruptedException
    Thread.sleep(1000);  // Wait for some time to allow the exception
                         // to be caught (demonstration only)
    c.shutdown();
  }
}

Compliant Solution (2) (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)

This noncompliant code example uses the advice suggested in the previous compliant solution. 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 StopSocket extends@Override Thread {
  private Socket s;
  private volatile boolean done = false;
  
  public public synchronized void run() { 
    while(!done) {
      try {
        s Random number = new Socket("somehost", 25Random(123L);
    int i   BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
     vector.capacity();
   String s = null;
        while((s = br.readLine()) !=done null)&& {i 
          // Blocks until end of stream (null)
        }> 0) {
        System.out.println("Blocked, will not get executed until some data is received. " + s);
      } catch (IOException ie) { 
          // Forward to handler
      } finally {
          System.out.println("Closing resources"vector.add(number.nextInt(100));
          done = truei--;
      }
    }
  }  

  public void shutdown() throws IOException {
    done = true;
  }
}

class Controller {
  public static void main(String[] args) throws InterruptedException, IOException {
    Container StopSocket sscontainer = new StopSocketContainer();
     Thread tthread = new Thread(sscontainer);
     tthread.start();
     Thread.sleep(10005000); 
     sscontainer.shutdown();
  }
}

Compliant Solution (Interruptible)

In this compliant solution, the A Socket connection is not affected by the InterruptedException that results with the use of the Thread.interrupt() method . The boolean flag solution does not work in such cases.

Compliant Solution (close socket connection)

This compliant solution closes the socket connection, both using the shutdown() method as well as the finally block. As a result, the thread is bound to stop due to a SocketException. Note that there is no way to keep the connection alive if the thread is to be cleanly halted immediatelyis 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.

class StopSocket extends Thread {
  private Socket s;
 
  public voidfinal run()class {Container 
implements Runnable   try {
  private final Vector<Integer> vector s = new Socket("somehost", 25);
      BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
      String s = null;
      while((s = br.readLine()) != null) { Vector<Integer>(1000);

  public Vector<Integer> getVector() {
        // Blocks until end of stream (null)return vector;
      }
      System.out.println("Blocked, will not get executed until some data is received. " + s);
  @Override public }synchronized catchvoid run(IOException ie) { 
    Random number =  // Handle the exception new Random(123L);
    }int finallyi {
        System.out.println("Closing resources"= vector.capacity();
        try {
          if(s != null)
            s.close();
        } catch (IOException e) { /* Forward to handler */ }while (!Thread.interrupted() && i > 0) {
    }
  }

  public void shutdown() throws IOException {  vector.add(number.nextInt(100));
    if(s != null) i--;
      s.close();}
  }
}

class Controller {
  public static void main(String[] args) throws InterruptedException, IOException {
    StopSocketContainer ssc = new StopSocketContainer();
    Thread tthread = new Thread(ssc);
    tthread.start();
    Thread.sleep(10005000); 
    ssthread.shutdowninterrupt();
  }
}

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

Compliant Solution (2) (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 StopSocket extends Thread {
  private volatile boolean done = false;
  public void run() { 
    while(!done) {
      try {
    	InetSocketAddress addr = new InetSocketAddress("somehost", 25);
        SocketChannel sc = SocketChannel.open(addr);
        ByteBuffer buf = ByteBuffer.allocate(1024);
        sc.read(buf);
        // ...
      } catch (IOException ie) {  
          // Handle the exception
      } finally {
          System.out.println("Closing resources");
          done = true;
      }
    }
  }  

  public void shutdown() throws IOException {
    done = true;
  }
}

Risk Assessment

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

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 05|AA. Java References#JPL 05]\] 14.12.1. Don't stop
\[[JavaThreads 04|AA. Java References#JavaThreads 04]\] 2.4 Two Approaches to Stopping a Thread

Related Guidelines

Android Implementation Details

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

Bibliography

...

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