在 Java 中有两种锁，一种是内置锁 synchronized，一种是显示锁 Lock，其中 Lock 锁是可中断锁，而 synchronized 则为不可中断锁。

所谓的中断锁指的是锁在执行时可被中断，也就是在执行时可以接收 interrupt 的通知，从而中断锁执行。

PS：默认情况下 Lock 也是不可中断锁，但是可以通过特殊的“手段”，可以让其变为可中断锁，接下来我们一起来看。

为什么需要可中断锁？

不可中断锁的问题是，当出现“异常”时，只能一直阻塞等待，别无其他办法，比如下面这个程序。下面的这个程序中有两个线程，其中线程 1 先获取到锁资源执行相应代码，而线程 2 在 0.5s 之后开始尝试获取锁资源，但线程 1 执行时忘记释放锁了，这就造成线程 2 一直阻塞等待的情况，实现代码如下：

  1. import java.util.concurrent.locks.Lock;
  2. import java.util.concurrent.locks.ReentrantLock;
  4. public class InterruptiblyExample {
  5.     public static void main(String[] args) {
  6.         Lock lock = new ReentrantLock();
  8.         // 创建线程 1
  9.         Thread t1 = new Thread(new Runnable() {
  10.             @Override
  11.             public void run() {
  12.                 lock.lock();
  13.                 System.out.println("线程 1：获取到锁.");
  14.                 // 线程 1 未释放锁
  15.             }
  16.         });
  17.         t1.start();
  19.         // 创建线程 2
  20.         Thread t2 = new Thread(new Runnable() {
  21.             @Override
  22.             public void run() {
  23.                 // 先休眠 0.5s，让线程 1 先执行
  24.                 try {
  25.                     Thread.sleep(500);
  26.                 } catch (InterruptedException e) {
  27.                     e.printStackTrace();
  28.                 }
  29.                 // 获取锁
  30.                 System.out.println("线程 2:等待获取锁.");
  31.                 lock.lock();
  32.                 try {
  33.                     System.out.println("线程 2：获取锁成功.");
  34.                 } finally {
  35.                     lock.unlock();
  36.                 }
  37.             }
  38.         });
  39.         t2.start();
  40.     }
  41. }

以上代码执行的结果如下：
image.png
从上述结果可以看出，此时线程 2 在等待获取锁的操作，然而经历了 N 久之后…
image.png
再次查看结果，依然是熟悉的画面：
image.png
线程 2 还在阻塞等待获取线程 1 释放锁资源，此时的线程 2 除了等之外，并无其他方法。

并且，当我们熟练地拿出了 JConsole，试图得到一个死锁的具体信息时，却得到了这样的结果：
image.png
并没有检测到任何死锁信息，从上图我们可以看出，当只有一个锁资源的时候，系统并不会把这种情况判定为死锁，当然也没有阻塞等待的具体信息喽，此时只剩下线程 2 孤单地等待着它的“锁儿”。

使用中断锁

然而，中断锁的出现，就可以打破这一僵局，它可以在等待一定时间之后，主动的中断线程 2，以解决线程阻塞等待的问题。

中断锁的核心实现代码是 lock.lockInterruptibly() 方法，它和 lock.lock() 方法作用类似，只不过使用 lockInterruptibly 方法可以优先接收中断的请求，中断锁的具体实现如下：

  1. import java.util.concurrent.locks.Lock;
  2. import java.util.concurrent.locks.ReentrantLock;
  4. public class InterruptiblyExample {
  5.     public static void main(String[] args) throws InterruptedException {
  6.         Lock lock = new ReentrantLock();
  8.         // 创建线程 1
  9.         Thread t1 = new Thread(new Runnable() {
  10.             @Override
  11.             public void run() {
  12.                 try {
  13.                     // 加锁操作
  14.                     lock.lock();
  15.                     System.out.println("线程 1:获取到锁.");
  16.                 } catch (InterruptedException e) {
  17.                     e.printStackTrace();
  18.                 }
  19.                 // 线程 1 未释放锁
  20.             }
  21.         });
  22.         t1.start();
  24.         // 创建线程 2
  25.         Thread t2 = new Thread(new Runnable() {
  26.             @Override
  27.             public void run() {
  28.                 // 先休眠 0.5s，让线程 1 先执行
  29.                 try {
  30.                     Thread.sleep(500);
  31.                 } catch (InterruptedException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.                 // 获取锁
  35.                 try {
  36.                     System.out.println("线程 2:尝试获取锁.");
  37.                     lock.lockInterruptibly(); // 可中断锁
  38.                     System.out.println("线程 2:获取锁成功.");
  39.                 } catch (InterruptedException e) {
  40.                     System.out.println("线程 2:执行已被中断.");
  41.                 }
  42.             }
  43.         });
  44.         t2.start();
  46.         // 等待 2s 后,终止线程 2
  47.         Thread.sleep(2000);
  48.         if (t2.isAlive()) { // 线程 2 还在执行
  49.             System.out.println("执行线程的中断.");
  50.             t2.interrupt();
  51.         } else {
  52.             System.out.println("线程 2:执行完成.");
  53.         }
  54.     }
  55. }

以上代码执行结果如下：
image.png
从上述结果可以看出，当我们使用了 lockInterruptibly 方法就可以在一段时间之后，判断它是否还在阻塞等待，如果结果为真，就可以直接将他中断，如上图效果所示。

但当我们尝试将 lockInterruptibly 方法换成 lock 方法之后（其他代码都不变），执行的结果就完全不一样了，实现代码如下：

  1. import java.util.concurrent.locks.Lock;
  2. import java.util.concurrent.locks.ReentrantLock;
  4. public class InterruptiblyExample {
  5.     public static void main(String[] args) throws InterruptedException {
  6.         Lock lock = new ReentrantLock();
  8.         // 创建线程 1
  9.         Thread t1 = new Thread(new Runnable() {
  10.             @Override
  11.             public void run() {
  12.                 try {
  13.                     // 加锁操作
  14.                     lock.lockInterruptibly();
  15.                     System.out.println("线程 1:获取到锁.");
  16.                 } catch (InterruptedException e) {
  17.                     e.printStackTrace();
  18.                 }
  19.                 // 线程 1 未释放锁
  20.             }
  21.         });
  22.         t1.start();
  24.         // 创建线程 2
  25.         Thread t2 = new Thread(new Runnable() {
  26.             @Override
  27.             public void run() {
  28.                 // 先休眠 0.5s，让线程 1 先执行
  29.                 try {
  30.                     Thread.sleep(500);
  31.                 } catch (InterruptedException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.                 // 获取锁
  35.                 try {
  36.                     System.out.println("线程 2:尝试获取锁.");
  37.                     lock.lock();
  38.                     System.out.println("线程 2:获取锁成功.");
  39.                 } catch (Exception e) {
  40.                     System.out.println("线程 2:执行已被中断.");
  41.                 }
  42.             }
  43.         });
  44.         t2.start();
  46.         // 等待 2s 后,终止线程 2
  47.         Thread.sleep(2000);
  48.         if (t2.isAlive()) { // 线程 2 还在执行
  49.             System.out.println("执行线程的中断.");
  50.             t2.interrupt();
  51.         } else {
  52.             System.out.println("线程 2:执行完成.");
  53.         }
  54.     }
  55. }

以上程序执行结果如下：
image.png
从上图可以看出，当使用 lock 方法时，即使调用了 interrupt 方法依然不能将线程 2 进行中断。

总结

本文介绍了中断锁的实现，通过显示锁 Lock 的 lockInterruptibly 方法来完成，它和 lock 方法作用类似，但 lockInterruptibly 可以优先接收到中断的通知，而 lock 方法只能“死等”锁资源的释放，同时这两个方法的区别也是常见的面试题，希望本文对你有用。

并发原创文章推荐

  1. 线程的 4 种创建方法和使用详解！
  2. Java中用户线程和守护线程区别这么大？
  3. 深入理解线程池 ThreadPool
  4. 线程池的7种创建方式，强烈推荐你用它…
  5. 池化技术到达有多牛？看了线程和线程池的对比吓我一跳！
  6. 并发中的线程同步与锁
  7. synchronized 加锁 this 和 class 的区别！
  8. volatile 和 synchronized 的区别
  9. 轻量级锁一定比重量级锁快吗？
  10. 这样终止线程，竟然会导致服务宕机？
  11. SimpleDateFormat线程不安全的5种解决方案！
  12. ThreadLocal不好用？那是你没用对！
  13. ThreadLocal内存溢出代码演示和原因分析！
  14. Semaphore自白：限流器用我就对了！
  15. CountDownLatch：别浪，等人齐再团！
  16. CyclicBarrier：人齐了，司机就可以发车了！
  17. synchronized 优化手段之锁膨胀机制！
  18. synchronized 中的 4 个优化，你知道几个？
  19. ReentrantLock 中的 4 个坑！
  20. 图解：为什么非公平锁的性能更高？
  21. 死锁的 4 种排查工具！
  22. 死锁终结者：顺序锁和轮询锁！
  23. 轮询锁在使用时遇到的问题与解决方案！

关注公号「Java中文社群」查看更多有意思、涨知识的 Java 并发文章。