Take the 2-minute tour ×

I saw many code invoke the method Thread.currentThread.interrupt() in the catch block, why?

share|improve this question

4 Answers 4

up vote 48 down vote accepted

This is done to keep state.

When you catch the InterruptException and swallow it, you essentially prevent any higher level methods/thread groups from noticing the interrupt. Which may cause problems.

By calling Thread.currentThread.interrupt(), you set the interrupt flag of the thread, so higher level interrupt handlers will notice it and can handle it appropriately.

Java Concurrency in Practice discusses this in more detail in Chapter 7.1.3: Responding to Interruption. Its rule is:

Only code that implements a thread's interruption policy may swallow an interruption request. General-purpose task and library code should never swallow interruption requests.

share|improve this answer




For this technique to work, it's critical that any method that catches an interrupt exception and is not prepared to deal with it immediately reasserts the exception. We say reasserts rather than rethrows, because it is not always possible to rethrow the exception. If the method that catches the InterruptedException is not declared to throw this (checked) exception, then it should "reinterrupt itself" with the following incantation:


This ensures that the Thread will reraise the InterruptedException as soon as it is able.

share|improve this answer

I think this code sample makes things a bit clear. The class which does the job :

   public class InterruptedSleepingThread extends Thread {

        public void run() {

        private void doAPseudoHeavyWeightJob() {
                //You are kidding me
                System.out.println(i + " " + i*2);
                //Let me sleep <evil grin>
                if(Thread.currentThread().isInterrupted()) {
                    System.out.println("Thread interrupted\n Exiting...");
                }else {

        protected void sleepBabySleep() {
            try {
            } catch (InterruptedException e) {

The Main Class :

   public class InterruptedSleepingThreadMain {

         * @param args
         * @throws InterruptedException
            InterruptedSleepingThread thread = new InterruptedSleepingThread();
            //Giving 10 seconds to finish the job.
            //Let me interrupt


Try calling interrupt without setting the status back.

share|improve this answer
+1: nice example. –  Unai Vivi Oct 17 '12 at 20:35

I would consider it a bad practice or at least a bit risky. Usually higher level methods do not perform blocking operations and they will never see InterruptedException there. If you mask it in every place you perform interruptible operation, you will never get it.

The only rationale for Thread.currentThread.interrupt() and not raising any other exception or signaling interrupt request in any other way (e.g. setting interrupted local variable variable in a thread's main loop) is the situation where you really can't do anything with the exception, like in the finally blocks.

See Péter Török's answer, if you want to better understand implications of the Thread.currentThread.interrupt() call.

share|improve this answer

Your Answer


