深入探索ReentrantLock(二)：解锁中断响应机制

 专栏导航

JVM工作原理与实战

RabbitMQ入门指南

从零开始了解大数据

目录

前言

一、ReentrantLock中断响应机制

1.lockInterruptibly()方法讲解

2.lockInterruptibly()相比于lock()的优势

3.lockInterruptibly()案例

总结

前言

Java并发编程中，ReentrantLock作为可重入互斥锁，提供了比synchronized更灵活的控制能力，包括非阻塞锁获取、中断响应及公平锁机制。本文深入探讨ReentrantLock的中断响应机制，助力开发者构建高效稳定的并发应用。

一、ReentrantLock中断响应机制

在Java并发编程中，锁机制是确保多线程环境下数据一致性和线程安全的关键手段。传统的synchronized关键字提供了一种基本的同步方式，它简单易用，但在某些场景下显得不够灵活。相比之下，ReentrantLock作为Java并发包java.util.concurrent.locks中的一个重要类，提供了比synchronized更丰富的功能，其中包括了对中断的响应能力，这一特性通过lockInterruptibly()方法实现。

1.lockInterruptibly()方法讲解

lockInterruptibly() 方法是ReentrantLock 类中的一个关键功能，它提供了一种更为精细控制的锁获取机制。当线程调用 lockInterruptibly() 尝试获取锁时，如果锁当前不可用，该线程将进入等待状态，但与此同时，它保持了对中断的敏感性。这意味着，如果在等待锁的过程中，该线程被其他线程通过调用其 interrupt() 方法进行中断，则会立即响应这一中断，并抛出一个 InterruptedException 异常。这一异常的中断抛出机制，允许线程优雅地提前退出等待锁的状态，进而可以根据应用逻辑执行其他任务或进行必要的异常处理流程。

在并发编程的复杂场景中，lockInterruptibly() 的这一特性显得尤为重要。它不仅有助于提升程序的响应性，使得程序能够更灵活地应对外部中断事件，如用户取消操作或系统级中断请求，还通过提供一种避免永久等待锁的方式，有效地降低了死锁的风险。并且它还增强了程序的健壮性，因为通过捕获并适当处理 InterruptedException，程序能够更优雅地处理中断情况，而不是简单地忽略它们或导致程序状态不一致。

lockInterruptibly()官方注释如下：

由该注释可以得出，在并发编程中，ReentrantLock 的 lockInterruptibly() 方法提供了一种机制，允许线程在尝试获取锁时保持对中断的敏感性。此方法首先检查锁是否可用：若锁当前未被其他线程占用，则立即获取锁并设置占用计数为1；若当前线程已持有此锁，则锁保持计数递增1并立即返回，允许重入。若锁由另一线程持有，则当前线程将禁用自身以进行线程调度并进入休眠状态，直到锁被当前线程成功获取或被其他线程中断。一旦锁被当前线程获取，其保持计数将被重置为1。重要的是，如果当前线程在进入此方法时已具有中断状态，或在等待锁的过程中被中断，则会抛出 InterruptedException 并清除当前线程的中断状态。这种设计确保了 lockInterruptibly() 方法作为一个显式中断点，优先响应中断，而非简单地等待锁的正常或重复获取，从而提高了并发程序的响应性和健壮性。

2.lockInterruptibly()相比于lock()的优势

相较于lock()方法，ReentrantLock提供的lockInterruptibly()方法展现出显著的优势。lock()方法在尝试获取锁而未能立即成功时，会将线程置于阻塞状态，且在此阻塞期间，线程对中断信号不敏感。这意味着，即便在等待锁的过程中线程被其他线程通过调用interrupt()方法尝试中断，该线程也不会因此立即退出等待状态，而是会坚持等待直至锁被释放并成功获取。这种特性在某些场景下可能限制了程序的响应性和灵活性。

相反，lockInterruptibly()方法则提供了一种更为灵活和强大的锁获取机制。该方法允许线程在等待锁的过程中保持对中断的敏感性，即如果线程在等待期间被中断，它会立即响应这一中断并抛出InterruptedException异常，从而允许线程提前退出等待状态。这一特性提升了并发程序的响应性，因为它允许开发者在程序设计中更加精细地控制线程的中断行为，并据此实现更复杂的并发逻辑和错误恢复机制。因此，lockInterruptibly()方法在处理需要高度并发控制和灵活中断响应的复杂应用场景时，相较于lock()方法具有显著的优势。

并且使用lockInterruptibly()可以在一定程度上缓解死锁问题，因为当系统检测到潜在的死锁风险时，可以通过中断相关线程来避免其无限期等待，被中断的线程可以释放已经持有的锁，并根据中断后的上下文决定是否重新尝试获取锁或执行其他任务。

3.lockInterruptibly()案例

以下案例模拟了在多线程环境下使用ReentrantLock时可能遇到的死锁情况，以及如何尝试通过中断线程来解除死锁。

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {

    private static ReentrantLock lock1 = new ReentrantLock();
    private static ReentrantLock lock2 = new ReentrantLock();

    static class LockThread implements Runnable {
        private ReentrantLock lock1;
        private ReentrantLock lock2;
        private String name;

        public LockThread(String name, ReentrantLock lock1, ReentrantLock lock2) {
            this.name = name;
            this.lock1 = lock1;
            this.lock2 = lock2;
        }

        @Override
        public void run() {
            try {
                System.out.println(name + " 正在尝试获取lock1...");
                lock1.lockInterruptibly();
                System.out.println(name + " 已获取lock1");
                // 模拟任务执行时间
                TimeUnit.MILLISECONDS.sleep(100);
                System.out.println(name + " 正在尝试获取lock2...");
                lock2.lockInterruptibly();
                System.out.println(name + " 已获取lock2");
                // 假设下面有需要两个锁同时持有的操作
                // ...
            } catch (InterruptedException e) {
                System.out.println(name + " 在等待锁时被中断");
                // 这里可以根据需要处理中断，比如重新抛出异常或继续执行
                // ...
            } finally {
                if (lock1.isHeldByCurrentThread()) {
                    lock1.unlock();
                    System.out.println(name + " 释放了lock1");
                }
                if (lock2.isHeldByCurrentThread()) {
                    lock2.unlock();
                    System.out.println(name + " 释放了lock2");
                }
            }
        }
    }

    public static void main(String[] args) throws Throwable {
        Thread x = new Thread(new LockThread("线程X", lock1, lock2));
        Thread y = new Thread(new LockThread("线程Y", lock2, lock1));
        x.start();
        y.start();
        // 等待足够的时间让线程进入死锁状态
        TimeUnit.SECONDS.sleep(1);
        // 中断其中一个线程，观察死锁是否被打破
        x.interrupt();
        // 等待一段时间以确保中断效果可见
        TimeUnit.SECONDS.sleep(2);
        // 下面可以添加额外的逻辑来检查线程状态和锁的状态
        // ...
    }
}

1. 定义锁：代码开始时定义了两个ReentrantLock实例（lock1和lock2），这些锁将被不同的线程用于同步访问共享资源。
2. 定义任务类：LockThread类实现了Runnable接口，代表了一个将要在独立线程中执行的任务。每个LockThread实例都需要一个线程名以及两个ReentrantLock实例（在这个例子中，线程会尝试以不同的顺序获取这两个锁）。
3. 执行任务：在run方法中，每个线程首先尝试获取第一个锁（对于线程X是lock1，对于线程Y是lock2），然后模拟了一些工作（通过TimeUnit.MILLISECONDS.sleep(100);），接着尝试获取第二个锁。两个线程尝试以相反的顺序获取锁，这可能导致死锁。
4. 处理中断：在尝试获取锁时，使用了lock.lockInterruptibly()方法，这使得线程在等待锁时可以被中断。如果在等待锁的过程中线程被中断，它将捕获InterruptedException并打印一条消息。在捕获中断后，通常需要决定是重新抛出异常、处理中断（例如，清理资源并退出），还是简单地继续执行（这通常不是推荐的做法，因为它可能会忽略中断的意图）。
5. 释放锁：无论线程是正常完成还是被中断，最终都会进入finally块，检查是否持有锁，并释放它们。这是防止死锁的一个重要步骤，因为它确保了即使发生异常，锁也会被释放。
6. 主线程：main方法创建了两个LockThread实例，分别在不同的线程中运行。然后，它等待一段时间（足够让两个线程都进入等待锁的状态），并中断其中一个线程以尝试打破潜在的死锁。之后，它再次等待一段时间以观察中断的效果。

运行结果：

总结

ReentrantLock的lockInterruptibly()方法通过允许线程在等待锁时被中断，显著增强了Java并发编程的灵活性和响应性。这一特性使得线程能够更智能地处理锁竞争和中断信号，有效避免死锁，优化资源利用率。在复杂并发系统中，合理利用lockInterruptibly()能够提升系统的整体稳定性和性能，是构建高效、可靠并发应用的重要工具之一。本文主要介绍了ReentrantLock的中断响应机制，助力开发者构建高效稳定的并发应用。