Making sure the thread is interrupted

Question

I want to interrupt a thread which is checking for the interrupted flag in each increment of an endless while loop. The only way to exit the loop is by throwing an InterruptedException.

Somewhere in the (inaccessible) code executed by the interruptable thread, a sleep operation is declaring an InterruptedException and a catch block where the exception is swallowed. In an unfortunate case, the thread will be interrupted while the sleep method is being executed, causing the interrupted flag to be reset. In such a case, the thread won't exit the endless while loop.

What would be the best strategy to avoid such a situation? My main thread in the code below calls interrupt in a loop until the interruptable thread is not alive anymore. Is it a reasonable strategy? What are the alternatives?

 public class InterruptableThreads extends Thread {

    public static Thread t1 = new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                while (true) {

                    if (Thread.currentThread().isInterrupted()) {
                        throw new InterruptedException();
                    }

                    try {
                        Thread.sleep(5000);
                    } catch (Exception e) {
                        System.out.println("Swallowing exception. Resetting interrupted flag");
                    }

                    System.out.println("t1 run");
                }
            } catch (InterruptedException e) {
                System.err.println("t1 interrupted.");
            }
        }

    });

    public static void main(String[] args) throws InterruptedException {

        t1.start();

        Thread.sleep(4000);

        while (t1.isAlive()) {
            t1.interrupt();
        }

        t1.join(1000);

        System.out.println("Finished!");


    }
}

Answer 1

The solution you presented, which consists to loop until the thread dies should work. I don't know if this is possible, but you may want to avoid active spinning by including the join statement within that loop:

    while (t1.isAlive()) {
        t1.interrupt();
        try {
            t1.join(1000);

        } catch(InterruptedException e) {
            ...
        }
    }

An alternative could be to isolate the execution of the interruption-swallowing code from the main loop of your interruptible thread:

public static Thread t1 = new Thread(new Runnable() {
    @Override
    public void run() {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<?> f = null;

        try {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    throw new InterruptedException();
                }

                f = executor.submit(new Runnable() {
                    // swallowing code
                });

                try {
                   f.get();

                } catch(CancellationException e) {
                  ...
                } catch(ExecutionException e) {
                  ...
                } // interrupted exceptions will be thrown from get() but not caught here                 

                System.out.println("t1 run");
            }
        } catch (InterruptedException e) {
            System.err.println("t1 interrupted.");
            if (f != null) {
              f.cancel(true);
            }

        } finally {
            executor.shutdownNow();
        }
    }

});

f.get() will give you the possibility to capture interruptions of t1 regardless of the state of the thread spun up by the executor service where the external code is executed and potentially "sleeping".

But adding another thread comes with additional complexity and the risks associated to it.

Answer 2

The best strategy is outlined in Java Concurrency in Practice by Brian Goetz. From memory, you re-interrupt the thread from within the catch block, or you throw the exception.

Also, catch the narrowest exception possible, not Exception.

                if (Thread.currentThread().isInterrupted()) {
                    throw new InterruptedException();
                }

                try {
                    Thread.sleep(5000);
                } catch (InterrutedException e) {         // <---- Narrow the scope here
                    System.out.println("Swallowing exception. Resetting interrupted flag");
                    Thread.currentThread().interrupt();   // <----- NEW
                }