Page History

All good things must come to an end, and so do threads when they Threads preserve class invariants when they are allowed to exit normally. Unfortunately, programmers Programmers often try attempt to forcefully terminate threads abruptly when they believe that the task has been accomplishedis complete, the request has been canceled, or the program needs to quickly shutdown. or Java Virtual Machine (JVM) must shut down expeditiously.

Certain thread A few 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 such example. It was intended to () method causes the thread to immediately throw a ThreadDeath exception. Two cases arise:

...

,

...

which usually stops the thread. 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.

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 given amount of time.

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

  public Vector<Integer> getVector

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

Noncompliant Code Example

This noncompliant code example shows how a thread forcefully comes to a halt when the Thread.stop method is invoked. Neither the catch nor the finally block is executed. Needless to say, any held monitors will be immediately released leaving the object in a delicate state.

class BadStop implements Runnable {
  public void run() {
    try {
      Thread.currentThread().sleep(1000);
    }catch(InterruptedException ie) { System.out.println("Performing cleanup"); } // not executed
    finally { System.out.println("Closing resources"); }  // not executed
     
    System.out.println("Done!");
  }
}

class Controller {
  public static void main(String[] args) {
    Thread t = new Thread(new BadStop());
    t.start();  
    t.interrupt();  // artificially induce an InterruptedException
    t.stop();  // force thread cancellation
  }
}

Compliant Solution

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 upon which the thread will start the cancellation process. The done flag has also been set immediately following the execution of the initial finally block statements so that the system does not continue to relinquish the resources that it has already released, in the event of done staying false.

class ControlledStop implements Runnable{
  protected volatile boolean done = false;
  public void run() {
    while(!done) {return vector;
      try {}

  @Override public synchronized void   Thread.currentThreadrun().sleep(1000); {
    Random number }catch(InterruptedException ie) { System.out.println("Performing cleanup"); }= new Random(123L);
    int i finally { 
        System.out.println("Closing resources"); = vector.capacity();
    while (i >  done = true; 0) {
      }
    } 
    System.out.println("Done!"vector.add(number.nextInt(100));
  }

  protected void shutdown(){ i--;
    done = true;}
  }
}

class Controller {
  public static void main(String[] args) throws InterruptedException {  
    ControlledStopThread cthread = new ControlledStop();
    Thread t = Thread(new ThreadContainer(c));
    tthread.start();
    t.interrupt();  // artificially induce an InterruptedException
    Thread.sleep(1000);  // wait for some time to allow the exception to be caught (demonstration only)5000);
    cthread.shutdownstop();
  }
}

Noncompliant Code Example

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 is used to set the flag to true. The thread's run() method polls the done flag and terminates when it is setThis noncompliant solution uses the advice suggested in the previous compliant solution. Unfortunately, this does not help in terminating the thread since it is blocked on some network IO due to the readLine method. The boolean flag trick will thus not work in such cases; a good alternative method to end the thread is required.

public final 
class StopSocketContainer extendsimplements ThreadRunnable {
  private final Vector<Integer> vector protected= Socket snew Vector<Integer>(1000);
  protectedprivate volatile boolean done = false;

  public voidVector<Integer> rungetVector() { 
    while(!done) {return vector;
  }

  public void tryshutdown() {
        sdone = new Socket("somehost",25)true;
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String s = null;}

  @Override public synchronized    while((s = br.readLine()) != nullvoid run() { 
    Random number =    // blocks until end of stream (null)new Random(123L);
    int i   }
        System.out.println("Blocked, will not get executed until some data is received. " + s= vector.capacity();
     while }catch (IOException ie) { System.out.println("Performing cleanup"); }
      finally!done && i > 0) {
        System.out.println("Closing resources"vector.add(number.nextInt(100));
        done = true;
      }i--;
    }
  }  

  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)

The In this compliant solution simply closes the socket connection, both using the shutdown method as well as in the finally block. Thus, 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 immediatelythe 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.

class StopSocket extends Thread {
  protected Socket s;
  public voidfinal run()class {Container 
implements   Runnable try {
  private final Vector<Integer> vector s = new Socket("localhost",80Vector<Integer>(1000);

  public    BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));Vector<Integer> getVector() {
      String s = nullreturn vector;
  }

  @Override public synchronized  while((s = br.readLine()) != nullvoid run() { 
    Random number =    // blocks until end of stream (null)new Random(123L);
    int i   }
      System.out.println("Blocked, will not get executed until some data is received. " + s= vector.capacity();
    }catchwhile (IOException ie) { System.out.println("Performing cleanup"); }
    finally !Thread.interrupted() && i > 0) {
      Systemvector.outadd(number.println("Closing resources");
      try {
        s.close(nextInt(100));
        } catch (IOException e) { e.printStackTrace(); }i--;
    }
  }

  public void shutdown() throws IOException {
    if(s != null)
      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 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

Trying to force thread shutdown can lead to Forcing a thread to stop can result in inconsistent object state and thus corrupt the object. Critical resources may could 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

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

\[[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

CON34-J. Avoid deadlock by requesting fine-grained locks in the proper order      08. Concurrency (CON)      08. Concurrency (CON)