一 API

public void interrupt()

public static boolean interrupted()

public boolean isInterrupted()

二 interrupt 说明

1 介绍

如下方法的调用会使得当前线程进入阻塞状态，而调用当前线程的 interrupt 方法，就可以打断阻塞
Object 的 wait 方法

Thread 的 sleep 方法

Thread 的 join 方法

InterruptibleChannel 的 io 操作

Selector 的 wakeup 方法

其他若干方法

上述这些方法都会使得当前线程进入阻塞，因此这种方法有时会被称为可中断方法，中断一个线程并不等于该线程生命周期结束，仅仅是打断了当前线程的阻塞状态。

一旦线程在阻塞的情况下被打断，都会抛出一个称为 InterruptedException 的异常，这个异常就像一个信号一样通知当前线程被打断了。

2 实战

package concurrent;

import java.util.concurrent.TimeUnit;

public class ThreadInterrptu {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                TimeUnit.MINUTES.sleep(1);
            } catch (InterruptedException e) {
                System.out.println("I am be interruputed");
                e.printStackTrace();
            }
        });
        thread.start();
        try {
            TimeUnit.MILLISECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();
    }
}

3 测试

I am be interruputed

java.lang.InterruptedException: sleep interrupted

at java.lang.Thread.sleep(Native Method)

at java.lang.Thread.sleep(Thread.java:340)

at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)

at concurrent.ThreadInterrptu.lambda$main$0(ThreadInterrptu.java:9)

at java.lang.Thread.run(Thread.java:748)

4 说明

该程序创建了一个线程，并且企图休眠1分钟，不过大约在2毫秒之后被主线程调用 interrupt 方法打断，程序的执行结果就是 I am be interruputed。

如果一个线程已经是死亡状态，那么尝试对其 interrput 会直接会忽略。

三 isInterrupted说明

interrupted  是 Thread 的一个成员方法，它主要判断当前线程是否被中断，该方法仅仅是对当前线程中断标识的一个判断，并不会影响标识发生任何改变。

1 代码

package concurrent;

import java.util.concurrent.TimeUnit;

public class ThreadisInterrupted {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (true) {
            }
        });
        thread.start();
        try {
            TimeUnit.MILLISECONDS.sleep(2);
            System.out.println("Thread is interrupted?" + thread.isInterrupted());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();
        System.out.println("Thread is interrupted?" + thread.isInterrupted());
    }
}

2 测试

Thread is interrupted?false

Thread is interrupted?true

对上面代码稍加改动，将循环执行改为 sleep 这个可中断方法，它会捕获到中断信号，并且会擦除 interrupt 标识。

package concurrent;

import java.util.concurrent.TimeUnit;

public class ThreadisInterrupted2 {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            public void run() {
                while (true) {
                    try {
                        TimeUnit.MINUTES.sleep(1);
                    } catch (InterruptedException e) {
                        System.out.println("Thread is interrupted?" + isInterrupted());
                    }
                }
            }
        };

        thread.setDaemon(true);
        thread.start();
        try {
            TimeUnit.MILLISECONDS.sleep(2);
            System.out.println("Thread is interrupted?" + thread.isInterrupted());
        } catch (
                InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();
        try {
            TimeUnit.MILLISECONDS.sleep(2);
            System.out.println("Thread is interrupted?" + thread.isInterrupted());
        } catch (
                InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试结果如下：

Thread is interrupted?false

Thread is interrupted?false

Thread is interrupted?false

由于在 run 方法中使用了 sleep 这个可中断方法，它会捕获到中断信号，并且会擦除 interrupt 标识，因此程序执行结果都是 false

四 interrupted 说明

1 说明

interrupted是一个静态方法，虽然它也用于判断当前线程是否被中断，但是它和成员方法  isInterrupted 方法还是有很大的区别，调用该方法会直接擦除掉线程的中断标识，如果注意的是，如果当前线程被打断，那么第一次调用 interrupted 方法会返回 true，并且立即擦除中断标识，以后调用永远都返回 false，除非再一次被中断。

2 代码

package concurrent;

import java.util.concurrent.TimeUnit;

public class ThreadisInterrupted3 {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            public void run() {
                while (true) {
                    System.out.println(Thread.interrupted());
                }
            }
        };

        thread.setDaemon(true);
        thread.start();
        try {
            TimeUnit.MILLISECONDS.sleep(2);
        } catch (
                InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();
    }
}

3 测试

false

false

false

false

false

false

true

false

false

false

false

false

false

只出现一次 true