Question: I'm trying to understand how threads work in Java and currently investigating how to implement looped threads that can be cancelled. Here's the code:

```
public static void main(String[] args) throws Exception {
    Thread t = new Thread() {
        @Override
        public void run() {
            System.out.println("THREAD: started");
            try {
                while(!isInterrupted()) {
                    System.out.printf("THREAD: working...\n");
                    Thread.sleep(100);
                }
            } catch(InterruptedException e) {
                // we're interrupted on Thread.sleep(), ok

                // EDIT
                interrupt();

            } finally {
                // we've either finished normally
                // or got an InterruptedException on call to Thread.sleep()
                // or finished because of isInterrupted() flag

                // clean-up and we're done
                System.out.println("THREAD: done");
            }               
        }
    };

    t.start();
    Thread.sleep(500);
    System.out.println("CALLER: asking to stop");
    t.interrupt();
    t.join();
    System.out.println("CALLER: thread finished");
}

```

The thread I create is *indended* to be interrupted sooner or later. So, I check isInterrupted() flag to decide whether I need to go on and also catch `InterruptedException` to handle cases when I'm in a kind of waiting operation (`sleep`, `join`, `wait`).

Things I'd like to clarify are:

1. Is it fine to use interruption mechanism for this kind of task? (comparing to having `volatile boolean shouldStop`)
2. Is this solution correct?
3. Is it normal that I swallow InterruptedException? I'm not really interested what was the piece of code where someone asked my thread to interrupt.
4. Are there any shorter ways to solve this problem? (the main point is having 'infinite' loop)

**EDIT**
Added call to `interrupt()` in catch for `InterruptedException`.

Answer: 
I am answering no. 3:

Basically the question is: What purpose does an Interrupted exception have? It tells you to stop blocking (e.g. sleeping) and return early.

There are two ways dealing with an InterruptedException:

* Rethrow it, so the thread remains interrupted
* set `Thread.currentThread.interrupt()` again and do your cleanup work. This way you can be sure that another method in your thread starting to sleep will throw again

Simply swallowing an `InterruptedException` is not a good idea regarding the purpose of such an interrupt which is to finally terminate. But you are only asked to interrupt so you still have time to clean up.

In this case this might be an 'overreaction' of myself, but typically such code is much more complicated and how do you know, that some follow-up-code in this Thread would not call a blocking method again?

**EDIT**

Otherwise I think what you're doing is fine. For me a bit surprising, though, because I never saw anyone in his own code actually doing it.

And interesting article explaining why can be found here: <http://www.ibm.com/developerworks/java/library/j-jtp05236/index.html>
1) The way in your example is preferable to using a volatile flag (which is redundant since you already have the interrupted flag), according to the *Java Concurrency in Practice* book. It is how InterruptedExceptions were intended to be used.

2) Yes

3) you can eat the exception as long as you restore the interrupt flag status. The exception doesn't represent an error so eating it doesn't lose any information, it is purely a means of transferring control. (Restoring the interrupt flag status is important for cases where you have nested control structures that each need to be informed that the thread is cancelling, for a simple example like yours it's good form but if it's missing it won't hurt anything.)

4) no