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

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

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

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

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

以上程序执行结果如下:
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 并发文章。