Java并发实践中的“使用中断取消”中是否有错字

Question

In the book, Java Concurrency in Practice by Brian Goetz et al, the example on page 141 (2006):

7.5: Using interruption for cancellation.

class PrimeProducer extends Thread {
}
...
public void cancel() { interrupt(); }

The confusing thing is that the book states that Threads should implement an Interruption Policy , while Runnable / Callable tasks should implement a Cancellation Policy .

Yet here we are with a cancel() method inside of a Thread object. What's up with that? A few pages before, an example with Runnable is given (7.1) with cancel() . In the case of tasks, I would expect to see a qualified interrupt() like this:

public void cancel() { Thread.currentThread().interrupt(); }

---

Extra, semi-relevant information

I am using an ExecutorService, so I deal with tasks (not threads--except for a thread factory for the ExecutorService), but I could not find any could examples of a full ExecutorService shutdown (of many threads) in the book.

My methods for starting tasks and stopping them are:

Map<CancellableRunnable, Future<?>> cancellableFutures = new HashMap<>(); // keep track of refs to tasks for stop()
public void init() {
  Future<?> future = myExecutorService.submit(myTask);
  cancellableFutures.put(myTask, future);
}

public void stop() {
  for (Future task : cancellableFutures.values()) {
    task.cancel(true); // also a confusing step. Should it be cancel() on Future or cancel() on task (Runnable/Callable)?
  }
}

Answer 1

In the case of tasks, I would expect to see a qualified interrupt() like this:

 public void cancel() { Thread.currentThread().interrupt(); }

That interrupts your own thread, not the thread running the task. There's no point in interrupting yourself if you want something else to stop what it's doing: you can simply stop what you're doing instead.

(You might interrupt the current thread, for example, if you have just caught an InterruptedException , and want to preserve the fact that the thread was interrupted. But you don't use this as a mechanism to start the interruption).

Answer 2

The confusing thing is that the book states that Threads should implement an Interruption Policy

Right,

class MyThread extends Thread {
    @Override
    public void interrupt() { ... }
}

while Runnable / Callable tasks should implement a Cancellation Policy.

Right,

// FutureTask = Runnable (for run) + Future<Void> (for cancel(boolean))
class MyTask extends FutureTask<Void> {
    @Override
    public boolean cancel(boolean mayInterruptIfRunning) { ... }

    @Override
    public void run() { ... }
}

Yet here we are with a cancel() method inside of a Thread object.

Thread is both Thread and Runnable , so both interrupt (to interrupt this thread) and cancel (to cancel this task, the task currently being run by this thread) should be defined.

public class Thread implements Runnable { ... }

The PrimeProducer example is a bit confusing because it assumes the task defined in PrimeProducer will be used outside PrimeProducer .

class PrimeProducer extends Thread {

    public void run() { 
        try {
            BigInteger p = BigInteger.ONE;
            while (!Thread.currentThread().isInterrupted())
                queue.put(p = p.nextProbablePrime()); 
        } catch (InterruptedException consumed) {
            /* Allow thread to exit */
        }
    }

    public void cancel() { interrupt(); }

}

It's very reasonable and accurate since we can do

Runnable runnable = new PrimeProducer();
new Thread(runnable).start();

It's rarely the case, though. It's highly likely we would simply go with

new PrimeProducer().start();

which would make the task we define in run context-aware and Thread.currentThread().isInterrupted() and isInterrupted() would mean the same. That's what your confusion over Thread.currentThread().interrupt() and interrupt() comes from.

Answer 3

To correctly close a thread, you have to ask it to close itself by calling thread.interrupt() and the thread should periodically check thread.isInterrupted() method.

See more details in official documentation .

For your example, you have an ExecutorService myExecutorService . To close all submitted threads (along with thread pool itself), you could call myExecutorService.shutdown() . As a result, the thread pool calls thread.interrupt() for all threads.

To stop required threads only, you do correct calling future.cancel(true) . In this case, your thread pool will be alive and will able to submit another task.