//定义sleep进入阻塞的任务
public class SleepBlocked implements Runnable{

    public void run() {
        try {
            TimeUnit.SECONDS.sleep(10);
        }catch (InterruptedException e) {
            System.out.println("interrupt from sleep...");
        }
        System.out.println("exiting from SleepBlocked run");
    }

}
//定义因为IO进入阻塞的任务
public class IOBlocked implements Runnable {

    InputStream input;

    public IOBlocked(InputStream input) {
        this.input = input;
    }

    public void run() {
        try {
            System.out.println("waiting for input...");
            input.read();
        }catch (IOException e) {
            System.out.println("IOException...");
            if(Thread.interrupted()) {
                System.out.println("interrupt from IOBlocked...");
            }else {
                throw new RuntimeException();
            }
        }
        System.out.println("exiting from IOBlocked......");
    }
}
//定义因为尝试获取对象锁进入阻塞的任务
public class SynchronizedBlocked implements Runnable{

    public synchronized void f() {
        while (true)
            Thread.yield();
    }

    public SynchronizedBlocked() {
        new Thread() {
            public void run() {
                f();
            }
        }.start();
    }

    public void run() {
        System.out.println("trying to call f()...");
        f();
        System.out.println("exiting from SynchronizedBlocked....");
    }
}

public class InterruptedTest {
    private static ExecutorService executor = Executors.newCachedThreadPool();

    static void test(Runnable task) throws InterruptedException{
        //使用Executor的submit方法提交任务，或者线程的参考，以便中断线程
　　　　  Future future = executor.submit(task);
        TimeUnit.SECONDS.sleep(1);
        System.out.println("interruptting "+task.getClass().getName());
　　　　 //通过传递true给Future对象的cancel方法，运行中断被阻塞的线程
        future.cancel(true);
        System.out.println("interrupt send to "+task.getClass().getName());
    }

    public static void main(String[] args) throws Exception{
        test(new SleepBlocked());
        test(new IOBlocked(System.in));
        test(new SynchronizedBlocked());

    }
}
输出：

interruptting com.thread.test.SleepBlocked
interrupt send to com.thread.test.SleepBlocked
interrupt from sleep...  //因为睡眠而阻塞的线程被中断
exiting from SleepBlocked run

//因为IO而阻塞的线程没有被中断
waiting for input...
interruptting com.thread.test.IOBlocked
interrupt send to com.thread.test.IOBlocked

//因为获取对象锁而阻塞的线程没有被中断

trying to call f()...
interruptting com.thread.test.SynchronizedBlocked
interrupt send to com.thread.test.SynchronizedBlocked
exiting from IOBlocked......

public class BlockedMutex{

    private Lock lock = new ReentrantLock();

    public void f() {
        try {
　　　　　　　//一直占有锁，除非被中断
            lock.lockInterruptibly();
        }catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName()+" interrupted from lock acquisition in f()");
        }
    }
}

public class LockBlocked implements Runnable {

    private BlockedMutex blockedMutex;

    public LockBlocked(BlockedMutex blockedMutex) {
        this.blockedMutex = blockedMutex;
    }

    public void run() {
        System.out.println(Thread.currentThread().getName()+" waiting for blockedMutex....");
        blockedMutex.f();
        System.out.println(Thread.currentThread().getName()+" Broken out of blocked call");
    }

}

public class InterruptedTest {public static void main(String[] args) throws Exception{
        BlockedMutex blockedMutex = new BlockedMutex();
        Thread t1 = new Thread(new LockBlocked(blockedMutex));
        Thread t2 = new Thread(new LockBlocked(blockedMutex));
        t1.start();
        t2.start();
        t2.interrupt();
    }
}
输出：

Thread-0 waiting for blockedMutex....
Thread-1 waiting for blockedMutex....
Thread-0 Broken out of blocked call
Thread-1 interrupted from lock acquisition in f()
Thread-1 Broken out of blocked call

public class InterruptedCheck implements Runnable {
    private double d = 1d;
    public void run() {
        try {
            while (!Thread.interrupted()) {
                System.out.println("sleeping...");
　　　　　　　　　　//线程睡眠2s，进入阻塞，如果在睡眠时间interrupt，将会抛出异常
                Thread.sleep(2000);
                System.out.println("calculating....");
　　　　　　　　　　//这里以运算模拟任务，要有一定的时间，但是线程不会进入阻塞状态。如果在运算期间进行interrupt，将不会抛出异常，且中断标志位被设置
                for(int i=1;i<25000000;i++) {
                    d = d + (Math.PI + Math.E) /d;
                }
            }
            System.out.println("detected interrupted, not from blocked...");

        }catch (InterruptedException e) {
            System.out.println("interrupted from blocked...");
        }
    }

}

    public static void main(String[] args) throws Exception{
        Thread thread = new Thread(new InterruptedCheck());
        thread.start();
　　　　//这里man的睡眠时间为不同的值，就可以在thread处于不同的状态（sleep进入阻塞或者正常执行运算）interrupt
        TimeUnit.MILLISECONDS.sleep(2100);
        System.out.println("interruptting...");
        thread.interrupt();
    }
输出：main的sleep时间为1500milsec时
sleeping...
interruptting...
interrupted from blocked...

main的sleep时间为2100milsec时

sleeping... 
calculating.... 
interruptting... 
detected interrupted, not from blocked...