Properly writing task that ExecutorService.shutdownNow() can stop?
===

I have a processing loop of the form

    while (true) {
        doWork();
        Thread.sleep(SLEEP_INTERVAL);
    }

I want to make a `Runnable` out of this that can play well with `ExecutorService` and which will exit when `ExecutorService.shutdownNow()` is called.

I'm looking to write it this way:

    public WorkerTask implements Runnable
    {
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                doWork();
                try {
                    Thread.sleep(SLEEP_INTERVAL);
                }
                catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }

Simple testing shows it at least appearing to work in that the task gets interrupted and will exit and the `ExecutorService` will shut down, and appears to do so whether the interrupt arrives while `doWork()` is processing or during the `sleep`.  (By varying how much work `doWork()` does and how big `SLEEP_INTERVAL` is I can pretty much control where the interrupt happens).

But when I google I see examples using `Thread.interrupted()` as well as `Thread.currentThread().isInterrupted()`.  I understand that the former clears the interrupted flag while the latter leaves it, but is there any other difference I need to care about?  

I also see versions where the result of `Thread.currentThread().isInterrupted()` or `Thread.interrupted()` is stored in a `volatile` variable and that variable is used as the `while` loop test condition.  Is that just a style or is there a need to do that?  In what I've written do I have to worry that somehow something can clear the interrupt flag between when it is set (whether by being received when the thread is live, or by my catching `InterruptedException` and reasserting the flag) and when `Thread.currentThread().isInterrupted()` is called in the loop test?