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

作者 | 王磊

创新互联公司专注于建宁企业网站建设,自适应网站建设,商城网站定制开发。建宁网站建设公司,为建宁等地区提供建站服务。全流程按需网站设计，专业设计，全程项目跟踪，创新互联公司专业和态度为您提供的服务

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

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

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

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

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

为什么需要可中断锁?

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

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

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

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

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

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

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

使用中断锁

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

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

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

以上代码执行结果如下：

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

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

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

以上程序执行结果如下：

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

总结

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

分享文章：什么是可中断锁？有什么用？怎么实现？
文章地址：http://www.shufengxianlan.com/qtweb/news1/123901.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制网站知识

同城分类信息

大橙子建站　　 　成都网站建设报价　　 　成都网站建设　　 　网站设计　　 　成都微信小程序开发　　 　域名注册　　 　简阳机房托管　　 　成都展柜设计公司　　 　品牌官网设计　　 　定制网站　　 　成都花箱　　 　重庆手机网站建设　　 　成都免费做网站公司　　 　绵阳托管服务器　　 　广汉锦华　　 　成都网络推广公司　　 　航空文化传媒　　 　手机网站制作　　 　响应式网站　　 　网络推广公司