precise behaviour of interrupt() method with respective to thread states in java

Question

I have read the post below

What does java.lang.Thread.interrupt() do? but i have not been able to get it completely right

I quote from @Mike_q answer to above question as below

Thread.interrupt() sets the interrupted status/flag of the target thread. Then code running in that target thread MAY poll the interrupted status and handle it appropriately. Some methods that block such as Object.wait() may consume the interrupted status immediately and throw an appropriate exception (usually InterruptedException)

It says while object is in WAITING it can consume interrupted status, so what happens when it is BLOCKED state waiting for object's lock ... ?

i have experimented below with that scenario and code is

at X: t2 is blocked

    public class interruptsyc
{
    static Object resource = new Object();
    public static void main(String []args)
    {
        System.out.println("started main");
        Thread1 t1=new Thread1("thread 1");
        t1.start();
        delay(1000);
        Thread2 t2 =new Thread2("thread 2");
        t2.start();
        delay(1000);
        t2.interrupt(); // X: at this point t2 is in blocked state waiting for resource's lock
        System.out.println(t2.getName()+t2.interrupted());
        delay(1000);
        System.out.println("end main");

    }
    static void delay(long n)
    {
        try
        {
        Thread.sleep(n);
        }
        catch(InterruptedException ex)
        {
            System.out.println(Thread.currentThread().getName()+Thread.interrupted());
            ex.printStackTrace();
        }
    }
    static class Thread1 extends Thread{

        Thread1(String name)
        {
            setName(name);
        }
        public void run()
        {
            synchronized(resource)
            {
                System.out.println("start 1");
                delay(6000);
                System.out.println("end 1");
            }
        }
    }
    static class Thread2 extends Thread{
        Thread2(String name )
        {
        setName(name);  
        }
        public void run()
        {
            synchronized(resource)
            {
                System.out.println("start 2");
                delay(2000);
                System.out.println("end 2");
            }
        }
    }
}

and output has below

started main
start 1
false
end main
end 1
start 2
thread 2false
java.lang.InterruptedException: sleep interrupted
        at java.lang.Thread.sleep(Native Method)
        at interruptsyc.delay(interruptsyc.java:25)
        at interruptsyc$Thread2.run(interruptsyc.java:59)
end 2

it seems that InterruptedException has been called ,when sleep method is called later... why is that ...?

again what is polling i didn't quite understand from what is said here

Polling occurs via the Thread.interrupted() method which returns the current thread's interrupted status AND clears that interrupt flag. Usually the thread might then do something such as throw InterruptedException.

again whenever i called Thread2.interrupted() method in above code it returned false (when i called just after t2.interrupt and in catch block)

Answer 1

it seems that InterruptedException has been called ,when sleep method is called later... why is that ...?

Because blocking/sleeping methods don't block immediately. They first check if the thread has been interrupted, and if it has been, they throw an InterruptedException immediately, in order for the thread to stop ASAP.

whenever i called Thread2.interrupted() method in above code it returned false

Because when blocking/sleeping methods throw an InterruptedException, they also clear the interrupt flag.

This is in the javadoc of Thread.sleep():

Throws InterruptedException - if any thread has interrupted the current thread. The interrupted status of the current thread is cleared when this exception is thrown.