线程中断的简单理解

静态方法 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) {
      }
  }

线程中断的简单理解

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

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

推荐阅读更多精彩内容