Threads always preserve class invariants when they are allowed to exit normally. Programmers often try to forcefully terminate threads when they believe that the task is accomplished, the request has been canceled or the program needs to quickly shutdown.
...
- If
ThreadDeathis left uncaught, it allows the execution of afinallyblock which performs the usual cleanup operations. This Use of theThread.stop()method is not a good idea highly inadvisable because of two reasons. First, no particular thread can be forcefully stopped because an arbitrary thread can catch the thrownThreadDeathexception and simply choose to ignore it. Second, stopping threads leads to abruptly results in the release of all the associated monitors, violating the guarantees provided by the critical sections. Moreover, the objects end up in an inconsistent state with arbitrary , nondeterministic behavior being a typical outcome.
- As a remediation measure, catching the
ThreadDeathexception on the other hand can itself ensnarl multithreaded code. For one, the exception can be thrown anywhere making it difficult to trace it and recover from the exceptional condition effectively. Also, there is nothing stopping a thread from throwing anotherThreadDeathexception while recovery is in progress.
...
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 is executed. Needless to say, any monitors that are held are immediately released, leaving the object in a delicate state.
| Code Block | ||
|---|---|---|
| ||
class BadStop implements Runnable {
public void run() {
try {
Thread.currentThread().sleep(1000);
} catch(InterruptedException ie) { // notNot executed
System.out.println("Performing cleanup");
} finally { // notNot executed
System.out.println("Closing resources");
}
System.out.println("Done!");
}
}
class Controller {
public static void main(String[] args) {
Thread t = new Thread(new BadStop());
t.start();
t.interrupt(); // artificiallyArtificially induce an InterruptedException
t.stop(); // forceForce thread cancellation
}
}
|
Compliant Solution (1)
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 , after which the thread will 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.
| Code Block | ||
|---|---|---|
| ||
class ControlledStop implements Runnable{
protected volatile boolean done = false;
public void run() {
while(!done) {
try {
Thread.currentThread().sleep(1000);
} catch(InterruptedException ie) {
System.out.println("PerformingInterrupted cleanupException"); }
// Handle the exception
} finally {
System.out.println("Closing resources");
done = true;
}
}
System.out.println("Done!");
}
protected void shutdown(){
done = true;
}
}
class Controller {
public static void main(String[] args) throws InterruptedException {
ControlledStop c = new ControlledStop();
Thread t = new Thread(c);
t.start();
t.interrupt(); // artificiallyArtificially induce an InterruptedException
Thread.sleep(1000); // waitWait for some time to allow the exception
// to be caught (demonstration only)
c.shutdown();
}
}
|
Compliant Solution (2)
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
This noncompliant solution code example uses the advice suggested in the previous compliant solution. Unfortunately, this does not help in terminating the thread because it is blocked on some network IO because of the readLine() method. The boolean flag trick does not work in such cases; a good alternative to end the thread is required.
| Code Block | ||
|---|---|---|
| ||
class StopSocket extends Thread {
protected Socket s;
protected volatile boolean done = false;
public void run() {
while(!done) {
try {
s = new Socket("somehost", 25);
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
String s = null;
while((s = br.readLine()) != null) {
// blocksBlocks until end of stream (null)
}
System.out.println("Blocked, will not get executed until some data is received. " + s);
} catch (IOException ie) {
System.out.println("PerformingIO cleanupException");
// Handle the exception
} finally {
System.out.println("Closing resources");
done = true;
}
}
}
public void shutdown() throws IOException {
done = true;
}
}
class Controller {
public static void main(String[] args) throws InterruptedException, IOException {
StopSocket ss = new StopSocket();
Thread t = new Thread(ss);
t.start();
Thread.sleep(1000);
ss.shutdown();
}
}
|
...
| Code Block | ||
|---|---|---|
| ||
class StopSocket extends Thread {
protected Socket s;
public void run() {
try {
s = new Socket("somehost", 25);
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
String s = null;
while((s = br.readLine()) != null) {
// blocksBlocks until end of stream (null)
}
System.out.println("Blocked, will not get executed until some data is received. " + s);
} catch (IOException ie) {
System.out.println("PerformingIO cleanupException");
// Handle the exception
} finally {
System.out.println("Closing resources");
try {
if(s != null)
s.close();
} catch (IOException e) { /* forwardForward to handler */ }
}
}
public void shutdown() throws IOException {
if(s != null)
s.close();
}
}
class Controller {
public static void main(String[] args) throws InterruptedException, IOException {
StopSocket ss = new StopSocket();
Thread t = new Thread(ss);
t.start();
Thread.sleep(1000);
ss.shutdown();
}
}
|
...