为什么 shutdownNow() 方法能够打破 Callable object 内部的 for-loop，但在 Runnable 内部却不能这样做，除非我们专门调用 break？

Question

I have this code snippet that runs a single thread executor with two tasks of either Callable, or Runnable type. Both tasks run a simple for-loop counter with Thread.sleep() delay per iteration. The second task starts off immediately after the first task is finished. The awaitTermination() method is supposed to shutdown executor before it manages to complete.

I understand that shutdownNow() calls interrupt() to a currently executing task as soon as time elapses in awaitTermination() , somehow managing to immediately break the for-loop inside the first task and aborting the second task if the type of object is MyCallableTask . Now, if I change the type of submitted objects to MyRunnableTask the code will also terminate the for-loop as expected, but only because I've included break in the try-catch block when calling Thread.sleep() .

@Override public void run() {
    for (int j = 0; j < forLoops; j++) {
        try {
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            break;
        }
    }
}

If there was no break, the code would have finished the for-loop first and then stop.

My question is why don't we need to include any breaks or returns in call() implementation of MyCallableTask ? I mean, how come the code succeeds to immediately break the for-loop in the call() method without any additional instructions?

@Override public Void call() throws Exception {
    for (int j = 0; j < forLoops; j++) {
        Thread.sleep(sleepTime);
    }
    return null;
}

Answer 1

InterruptedException is a checked exception.

You either have to handle it inside the method (with a try/catch), or declare that the method throws it (or a superclass).

Runnable implementations can't throw checked exceptions like InterruptedException (its base declaration doesn't have throws Exception or throws InterruptedException ); Callable can, because its declaration does.

---

Btw, your Runnable case should call Thread.currentThread().interrupt() before the break, so that anything which called that Runnable can also know it was interrupted.

You also don't really need the break of you put the try/catch around the loop instead of inside it.