什么是可中断锁？有什么用？怎么实现？

作者 | 王磊

来源 | Java中文社群(ID：javacn666)

转载请联系授权(微信ID：GG_Stone

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

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

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

为什么需要可中断锁?什可锁有什用实现

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

import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; publicclass InterruptiblyExample {      public static void main(String[] args) {          Lock lock = new ReentrantLock();         // 创建线程 1         Thread t1 = new Thread(new Runnable() {              @Override             public void run() {                  lock.lock();                 System.out.println("线程 1：获取到锁.");                 // 线程 1 未释放锁             }         });         t1.start();         // 创建线程 2         Thread t2 = new Thread(new Runnable() {              @Override             public void run() {                  // 先休眠 0.5s，让线程 1 先执行                 try {                      Thread.sleep(500);                 } catch (InterruptedException e) {                      e.printStackTrace();                 }                 // 获取锁                 System.out.println("线程 2:等待获取锁.");                 lock.lock();                 try {                      System.out.println("线程 2：获取锁成功.");                 } finally {                      lock.unlock();                 }             }         });         t2.start();     } } 

以上代码执行的结果如下：

从上述结果可以看出，此时线程 2 在等待获取锁的操作，然而经历了 N 久之后...再次查看结果，依然是熟悉的画面：

线程 2 还在阻塞等待获取线程 1 释放锁资源，此时的线程 2 除了等之外，并无其他方法。

并且，但我们熟练的拿出了 JConsole，试图得到一个死锁的具体信息时，却得到了这样的结果：

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

使用中断锁

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

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

import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; publicclass InterruptiblyExample {      public static void main(String[] args) throws InterruptedException {          Lock lock = new ReentrantLock();         // 创建线程 1         Thread t1 = new Thread(new Runnable() {              @Override             public void run() {                  try {                      // 加锁操作                     lock.lock();                     System.out.println("线程 1:获取到锁.");                 } catch (InterruptedException e) {                      e.printStackTrace();                 }                 // 线程 1 未释放锁             }         });         t1.start();         // 创建线程 2         Thread t2 = new Thread(new Runnable() {              @Override             public void run() {                  // 先休眠 0.5s，让线程 1 先执行                 try {                      Thread.sleep(500);                 } catch (InterruptedException e) {                      e.printStackTrace();                 }                 // 获取锁                 try {                      System.out.println("线程 2:尝试获取锁.");                     lock.lockInterruptibly(); // 可中断锁                     System.out.println("线程 2:获取锁成功.");                 } catch (InterruptedException e) {                      System.out.println("线程 2:执行已被中断.");                 }             }         });         t2.start();         // 等待 2s 后,终止线程 2         Thread.sleep(2000);         if (t2.isAlive()) {  // 线程 2 还在执行             System.out.println("执行线程的中断.");             t2.interrupt();         } else {              System.out.println("线程 2:执行完成.");         }     } } 

以上代码执行结果如下：

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

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

import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; publicclass InterruptiblyExample {      public static void main(String[] args) throws InterruptedException {          Lock lock = new ReentrantLock();         // 创建线程 1         Thread t1 = new Thread(new Runnable() {              @Override             public void run() {                  try {                      // 加锁操作                     lock.lockInterruptibly();                     System.out.println("线程 1:获取到锁.");                 } catch (InterruptedException e) {                      e.printStackTrace();                 }                 // 线程 1 未释放锁             }         });         t1.start();         // 创建线程 2         Thread t2 = new Thread(new Runnable() {              @Override             public void run() {                  // 先休眠 0.5s，让线程 1 先执行                 try {                      Thread.sleep(500);                 } catch (InterruptedException e) {                      e.printStackTrace();                 }                 // 获取锁                 try {                      System.out.println("线程 2:尝试获取锁.");                     lock.lock();                     System.out.println("线程 2:获取锁成功.");                 } catch (Exception e) {                      System.out.println("线程 2:执行已被中断.");                 }             }         });         t2.start();         // 等待 2s 后,终止线程 2         Thread.sleep(2000);         if (t2.isAlive()) {  // 线程 2 还在执行             System.out.println("执行线程的中断.");             t2.interrupt();         } else {              System.out.println("线程 2:执行完成.");         }     } } 

以上程序执行结果如下：

从上图可以看出，当使用 lock 方法时，即使调用了 interrupt 方法依然不能将线程 2 进行中断。

总结

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

很赞哦!（31872）