How to cancel associated Runnables when CountDownLatch.await() is interrupted

Question

I'm using a java.util.concurrent.CountDownLatch object (latch) to control a set of Runnables which get executed via a thread pool (which could also be executing other Runnables).

In certain (and desirable) instances, the main thread is interrupted whilst waiting in latch.await(). and I need to catch and deal with java.lang.InterruptedException.

What I want to do is to interrupt all the threads that are currently running in the thread pool on behalf of this particular latch, and cancel any Runnables that are queued to run in that pool. To re-iterate: I can't simply interrupt everything in the pool and cancel all pending queued Runnables as it used by other processes.

I presume this is a standard construct, but can't find it.

Therefore before I embark on implementing this from scratch, I would be delighted to know if Java has a canned object or a standard approach for doing this.

I would suggest that you should use another pool for the threads that you want to cancel so that you can call `shutdownNow()` on it. — Gray, Jun 24 '13 at 14:05
Obviously all of your threads can watch a `volatile boolean shutdown` field and stop when it goes to true. — Gray, Jun 24 '13 at 14:05
@Gray, your second idea has some potential; if I can find something I can override in java.util.concurrent.ExecutorService which is called when a Runnable is about to be ran. Then I can check the shutdown flag and not run that task. — Bathsheba, Jun 24 '13 at 14:13

Gray · Accepted Answer · 2013-06-24T14:40:32.070

can't simply interrupt everything in the pool and cancel all pending queued Runnables as it used by other processes

The easiest fix to this is to separate out these Runnables into their own thread-pool so you can then call shutdownNow() on that pool only which interrupts all of the tasks in that pool. Sounds like you can't do that.

An alternative would be to teach your code to look for a volatile boolean shutdown field and stop running once that field goes to true.

 static final volatile boolean shutdown;
 ...
 public void run() {
      if (shutdown) {
         return;
      }
      ...
 }

Or if your tasks loop then you'd do:

 public void run() {
      while (!shutdown && !Thread.currentThread().isInterrupted()) {
         ...
      }
 }

If you don't have control over your Runnable class then you could write a little wrapping class that looks at the shutdown boolean:

 public class WrappedRunnable implements Runnable {
      private final Runnable delegate;
      public WrappedRunnable(Runnable delegate) {
          this.delegate = delegate;
      }
      public void run() {
          if (!shutdown) {
             delegate.run();
          }
      }
 }

From Bathsheba: I can't do another pool due to adjacent and an indeterminate number of tasks using the same pool. — Gray, Jun 24 '13 at 14:30

score 0 · Answer 2 · answered Jun 24 '13 at 15:42

My solution, inspired from @Gray, was to extend CountDownLatch to include a field private volatile boolean m_interrupted = false;

Then in @Override public void CountDownLatch.await() I set this flag to true if I catch an java.lang.InterruptedException object.

The neat thing about this is that I am already passing latch into all the Runnables in order to call latch.countDown() in a finally block.

So in the class that I've extended from Runnable, I check the interrupted status before doing any further work.

(Stopping any running threads is done using interrupt()).

How to cancel associated Runnables when CountDownLatch.await() is interrupted

2 Answers2