静态方法 Thread.interrupted()
实例方法 Thread.currentThread().isInterrupted()
这2个方法会返回线程的中断状态，并把中断状态重置！也就是说，调用这个方法之后，线程就不再是中断状态了，就可以开始新一轮的运行了。

实例方法 Thread.currentThread().interrupt()
有一个运行中的线程 t，在另一个线程中调用了 t.interrupt() 方法时，t 线程的中断状态就被置为了true，当然，t 线程并不会中断运行，只是中断状态被置为了 true 。这个看似没啥用，其实很有用。

interrupt() 的用途一：通过设置线程的中断状态可以唤醒阻塞/睡眠中的线程

当线程 t 在 run 方法中调用了 Object 类 的 wait(), wait(long), or wait(long, int) 方法或者 Thread 类的 join(), join(long), join(long, int), sleep(long), sleep(long, int) 方法或者 ServerSocket.accept() 或者 DatagramSocket.receive() 等方法进入阻塞状态后，线程就会一直检查中断状态，一旦发现被标记为了中断，就立即抛出 InterruptedException，被唤醒；要想唤醒线程，就可以在另一个线程中调用 t.interrupt() 方法，调用后，这些阻塞方法就会抛出一个 InterruptedException，这就达到了唤醒线程 t 的目的了，当然，抛出中断异常的同时，线程 t 的中断状态也会被置为 false，这个操作不是在 java 层实现的，因此 jdk 中看不到相关代码，但是 interrupt() 的 API 注释写的很清楚。

• 结束线程的常见写法（推荐）

  class MyThread implements Runnable {
      public boolean stop;
    
      @Override
      public void run() {
          while(!stop) {
              // do something
          
              // 执行完本轮任务，休眠1s，防止没任务时线程空转。
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
  }
  

• 另一种写法

  class MyThread implements Runnable {
      @Override
      public void run() {
          while(!Thread.interrupted()) { // 注意这里，控制线程结束的条件和上面的代码不一样
              // do something
  
              // 执行完本轮任务，休眠1s，防止没任务时线程空转。
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  Thread.currentThread.interrupt(); // 将当前线程标记为中断状态
              }
          }
      }
  }
  

interrupt() 的用途二：通过设置线程的中断状态可以终止死锁

synchronized关键字、ReentrantLock类的lock()、lockInterruptibly()、tryLock()、tryLock(long, java.util.concurrent.TimeUnit) 都能获取锁，但是 lockInterruptibly() 和 tryLock(long, java.util.concurrent.TimeUnit) 会在获取锁的过程中检测线程中断状态，一旦发现线程处于中断状态则立即抛出 InterruptedException ，另外三种方式则不检测中断。

• 无法响应中断的线程，无法终止死锁。

    public static void main(String[] args) {
        Object lock1 = new Object();
        Object lock2 = new Object();
  
        Thread t1 = new Thread(
                () -> {
                    deadLock(lock1, lock2); // 先锁1，后锁2
                }
        );
        Thread t2 = new Thread(
                () -> {
                    deadLock(lock2, lock1); // 注意，顺序相反
                }
        );
        
        t1.start();
        t2.start();
        t1.interrupt();
        t2.interrupt();
        System.out.println("发生了死锁，2个线程阻塞了，无法响应中断，因此，进程无法结束。");
    }
  
    private static void deadLock(Object lock1, Object lock2) {
        synchronized (lock1) {
            sleep();
            synchronized(lock2){
                System.out.println("...");
            }
        }
    }
  
    private static void sleep() {
        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start < 100) {
        }
    }
  

• 可以响应中断的线程，是可以终止死锁的。

    public static void main(String[] args) {
        ReentrantLock lock1 = new ReentrantLock();
        ReentrantLock lock2 = new ReentrantLock();
  
        Thread t1 = new Thread(
                () -> {
                    deadLock(lock1, lock2); // 先锁1，后锁2
                }
        );
        Thread t2 = new Thread(
                () -> {
                    deadLock(lock2, lock1); // 注意，顺序相反
                }
        );
  
        t1.start();
        t2.start();
        sleep(110); // 等 t1 和 t2 死锁之后，再发中断信号。
        t1.interrupt();
        t2.interrupt();
        System.out.println("发生了死锁，但是阻塞住线程的方法可以响应中断，因此，进程可以结束。");
    }
  
    private static void deadLock(ReentrantLock lock1, ReentrantLock lock2) {
        try {
            lock1.lockInterruptibly();
            sleep(100);
            lock2.lockInterruptibly(); // 可以响应中断的函数
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
  
    private static void sleep(int sleepTime) {
        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start < sleepTime) {
        }
    }