Program continues to run despite InterruptedException

Question

I started learning java and I am now at the concurrency chapter. After reading some stuff about concurrency I tried an example of my own.

public class Task implements Runnable{

public void run() {
    while(!Thread.interrupted()) {
        try {
            System.out.println("task");
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e) {
            System.out.println("interrupted");
        }
    }
}

}

public static void main(String[] args) throws Exception {
    ExecutorService exec = Executors.newCachedThreadPool();
    exec.execute(new Task());
    TimeUnit.SECONDS.sleep(10);
    exec.shutdownNow();
}

The problem is that i was expecting to see the following output:

task
task
task
task
task
interrupted

but after I get this, the program continues printing until I close it.
So, my question is what am I doing wrong? why does the program continues printing?

have you tried `exec.shutdown()` instead of `exec.shutdownNow()`? — Sam DeHaan, Aug 12 '11 at 17:03
exec.shutdown() works even worse. it doesn't even interrupt the thread. — Daniel S., Aug 12 '11 at 17:06
http://stackoverflow.com/questions/2358139/stop-an-infinite-loop-in-an-executorservice-task — Eric J., Aug 12 '11 at 17:06
Instead of just catching the interrupted exception, you should raise it again to get out of the while. — Maurício Linhares, Aug 12 '11 at 17:09

score 7 · Answer 1 · answered Aug 12 '11 at 17:08

When you shutdown the executor, it tries to stop its running tasks by interrupting them. This causes an InterruptedException to be thrown, but you just swallow it and continue. You should return in your catch clause, and/or reset the interrupted status of the thread by calling Thread.currentThread.interrupt(), which will reset the interrupted status and exit the loop.

djna · Answer 2 · 2011-08-12T17:31:47.327

4

You're still in the while loop, add a break or some other way out of the loop.

    catch (InterruptedException e) {
        System.out.println("interrupted");
        break;
    }

Threading in Java is kind of a cooperative activity, you've been asked to stop, but you need to be polite enough to actually do it. This allows the thread time to tidy its affairs before its demise.

As is explained in detail by Simon and Amir, your loop termination condition is surprisingly not sufficient.

edited Aug 12 '11 at 17:31

answered Aug 12 '11 at 17:05

djna

54,992
14
74
117

2

You need to use isInterrupted because interupted() clears the flag. – Amir Raminfar Aug 12 '11 at 17:10

Simon Lehmann · Accepted Answer · 2011-08-12T20:33:43.740

The section about interrupts in the Java tutorials about concurrency explain the problem quite well:

The Interrupt Status Flag

The interrupt mechanism is implemented using an internal flag known as the interrupt status. Invoking Thread.interrupt sets this flag. When a thread checks for an interrupt by invoking the static method Thread.interrupted, interrupt status is cleared. The non-static isInterrupted method, which is used by one thread to query the interrupt status of another, does not change the interrupt status flag.

By convention, any method that exits by throwing an InterruptedException clears interrupt status when it does so. However, it's always possible that interrupt status will immediately be set again, by another thread invoking interrupt.

So when you catch the InterruptedException within the loop, the interrupted status is already reset and thus, the next call of Thread.interrupted() will return false, which in turn keeps the while loop running. To stop the loop, you have the following options:

Use break to exit the loop
Use return to exit the whole method
Move the try-catch-block to outside the while loop (as suggested by Nathan Hughes)
Call interrupt() on the current thread to set the interrupted flag again
Use a separate boolean to control the loop and set that flag accordingly in the catch-block
Make the task a recurring task by using a ScheduledExecutorService and dropping the loop from the run-method of your Runnable

there's another option: move the try-catch to outside the while loop. — Nathan Hughes, Aug 12 '11 at 17:51

score 1 · Answer 4 · answered Aug 12 '11 at 17:07

"There are no guarantees beyond best-effort attempts to stop processing actively executing tasks. For example, typical implementations will cancel via Thread.interrupt(), so if any tasks mask or fail to respond to interrupts, they may never terminate."

source : http://download.oracle.com/javase/1,5.0/docs/api/java/util/concurrent/ExecutorService.html#shutdownNow()

Program continues to run despite InterruptedException

4 Answers4