When does Java's Thread.sleep throw InterruptedException?

Question

When does Java's Thread.sleep throw InterruptedException? Is it safe to ignore it? I am not doing any multi-threading. I just want to wait for a few seconds before retrying some operation.

Thordis

#1025151 – Parturition

Depends in which sense you mean "ignore". InterruptedException is a caught exception, so you can't compile unless you handle or declare this type of exception on any method which joins or sleeps a Thread, or calls wait() on Object. – Istanbul

Answer 1

You should generally NOT ignore the exception. Take a look at the following paper:

Don't swallow interrupts

Sometimes throwing InterruptedException is not an option, such as when a task defined by Runnable calls an interruptible method. In this case, you can't rethrow InterruptedException, but you also do not want to do nothing. When a blocking method detects interruption and throws InterruptedException, it clears the interrupted status. If you catch InterruptedException but cannot rethrow it, you should preserve evidence that the interruption occurred so that code higher up on the call stack can learn of the interruption and respond to it if it wants to. This task is accomplished by calling interrupt() to "reinterrupt" the current thread, as shown in Listing 3. At the very least, whenever you catch InterruptedException and don't rethrow it, reinterrupt the current thread before returning.

public class TaskRunner implements Runnable {
    private BlockingQueue<Task> queue;
 
    public TaskRunner(BlockingQueue<Task> queue) { 
        this.queue = queue; 
    }
 
    public void run() { 
        try {
             while (true) {
                 Task task = queue.take(10, TimeUnit.SECONDS);
                 task.execute();
             }
         }
         catch (InterruptedException e) { 
             // Restore the interrupted status
             Thread.currentThread().interrupt();
         }
    }
}

• From Don't swallow interrupts

---

See the entire paper here:

http://www.ibm.com/developerworks/java/library/j-jtp05236/index.html?ca=drs-

Uam

Answer 2

If an InterruptedException is thrown it means that something wants to interrupt (usually terminate) that thread. This is triggered by a call to the threads interrupt() method. The wait method detects that and throws an InterruptedException so the catch code can handle the request for termination immediately and does not have to wait till the specified time is up.

If you use it in a single-threaded app (and also in some multi-threaded apps), that exception will never be triggered. Ignoring it by having an empty catch clause I would not recommend. The throwing of the InterruptedException clears the interrupted state of the thread, so if not handled properly that info gets lost. Therefore I would propose to run:

} catch (InterruptedException e) {
  Thread.currentThread().interrupt();
  // code for stopping current task so thread stops
}

Which sets that state again. After that, finish execution. This would be correct behaviour, even tough never used.

What might be better is to add this:

} catch (InterruptedException e) {
  throw new RuntimeException("Unexpected interrupt", e);
}

...statement to the catch block. That basically means that it must never happen. So if the code is re-used in an environment where it might happen it will complain about it.

Rashida

Assertions in Java are off by default. So it's better to just throw a RuntimeException. – Droplight

Answer 3

Methods like sleep() and wait() of class Thread might throw an InterruptedException. This will happen if some other thread wanted to interrupt the thread that is waiting or sleeping.

Euryale

Answer 4

A solid and easy way to handle it in single threaded code would be to catch it and retrow it in a RuntimeException, to avoid the need to declare it for every method.

Gaughan

Answer 5

From the docs:

An InterruptedException is thrown when a thread is waiting, sleeping, or otherwise occupied, and the thread is interrupted, either before or during the activity.

In other words, InterruptedException occurs when some code has called the interrupt() method on a specific thread. It's a checked exception, and many blocking operations in Java can throw it.

The purpose of the interrupt system is to provide a alternative workflow for allowing threads to interrupt tasks in other threads. An interruption necessarily may not interrupt a running thread but it can also request that the thread interrupt itself at the next convenient opportunity.

Threads may get blocked for several reasons:

• waiting to wake up from a Thread.sleep()
• waiting to acquire a lock, waiting for I/O completion
• waiting for the result of a computation in another thread, etc.

The InterruptedException is usually thrown by all blocking methods so that it can be handled and the corrective action can be performed.

However, in majority of the cases as our code is a part of a Runnable, in this situation, we must catch it and restore the status.

There are a handfull of methods in Java that throws InterruptedException. Some examples are:

• Object class:

  • Thread.sleep()
  • Thread.join()
  • wait()

• BlockingQueue:

  • put()
  • take()

Ironclad

Answer 6

From personal experience, I simply changed thread.sleep() into this.sleep()

Harlie

As it’s currently written, your answer is unclear. Please edit to add additional details that will help others understand how this addresses the question asked. You can find more information on how to write good answers in the help center. – Hernandes