Java内置锁：深度解析Lock接口中lock方法和lockInterruptibly方法

Java11中的Lock接口提供lock()和lockInterruptibly()两种锁定方法，用于获取锁，但处理线程中断时有所不同，lock()使线程等待直到锁释放，期间无视中断；而lockInterruptibly()在等待中若收到中断请求，会立即响应并抛出异常，这种机制使lockInterruptibly()更灵活，能更好处理线程中断，避免无意义等待，提升系统响应性和效率。

定义

在Java 11中，Lock接口提供了两种锁定方法：lock()和lockInterruptibly()，这两种方法虽然都是为了获取锁，但在处理线程中断时有着显著的不同。

lock()方法是一种基本的锁定机制，当一个线程调用这个方法时，如果锁已经被其他线程持有，那么调用线程就会进入等待状态，直到锁被释放，在等待的过程中，这个线程会无视中断请求，也就是说，即使有其他线程调用了这个等待线程的interrupt()方法，它也不会有任何响应，依旧会“执着”地等待锁的释放。

而lockInterruptibly()方法则不同，它提供了一种更加“灵活”的锁定机制，当一个线程调用这个方法时，如果锁已经被其他线程持有，那么这个线程同样会进入等待状态，但是，在等待的过程中，如果这个线程收到了中断请求（即有其他线程调用了它的interrupt()方法），那么它就会立即响应中断，不再等待锁的释放，而是抛出一个InterruptedException异常。

举个例子来说明这两种方法的区别，假设有一个仓库，只有一把钥匙可以打开（这里把钥匙比作锁），现在有两个人（线程）都想进入仓库取东西，

1. 如果第一个人使用lock()方法，那么在他拿到钥匙并进入仓库之前，即使有人叫他（发送中断请求），他也不会理睬，直到他取完东西出来并把钥匙交给下一个人。
2. 如果第一个人使用lockInterruptibly()方法，那么在他等待钥匙的时候，如果有人叫他（发送中断请求），他就会立即响应，放弃等待，转而去做其他事情。

lockInterruptibly()方法就提供了一种更加“人性化”的锁定机制，能够更好地处理线程的中断请求，避免线程长时间无意义地等待锁的释放。

代码案例

使用lock()

Lock接口通过其实现类ReentrantLock来使用，以下是一个使用ReentrantLock和lock()方法的示例代码，该代码模拟了上面描述的“仓库”案例，在这个例子中，有一个Warehouse类，它包含一个资源，并且使用ReentrantLock来控制对这个资源的访问，如下代码：

import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
  
// 仓库类，使用Lock来控制访问  
public class Warehouse {  
    private final Lock lock = new ReentrantLock();  
    private String resource = "Goods inside the warehouse"; // 仓库中的资源  
  
    // 获取仓库资源的方法  
    public void accessResource() {  
        lock.lock(); // 获取锁  
        try {  
            // 模拟长时间的操作  
            try {  
                Thread.sleep(1000);  
            } catch (InterruptedException e) {  
                // 注意：这里不会响应中断，因为使用了lock()方法  
                e.printStackTrace();  
            }  
            System.out.println(Thread.currentThread().getName() + " accessed the resource: " + resource);  
        } finally {  
            lock.unlock(); // 释放锁  
        }  
    }  
}  
  
// 客户端代码，模拟两个线程同时尝试访问仓库资源  
public class Client {  
    public static void main(String[] args) {  
        Warehouse warehouse = new Warehouse();  
  
        // 创建并启动两个线程，它们将尝试访问仓库资源  
        Thread thread1 = new Thread(() -> warehouse.accessResource(), "Thread-1");  
        Thread thread2 = new Thread(() -> warehouse.accessResource(), "Thread-2");  
  
        thread1.start();  
        thread2.start();  
  
        // 注意：由于使用了lock()方法，即使尝试中断线程，它们也不会响应，直到它们自然地完成操作  
    }  
}

在上面代码中，Warehouse类有一个accessResource方法，它使用lock()方法获取锁，并在finally块中释放锁，以确保锁总是会被释放，无论是否发生异常，Client类创建了两个线程，它们几乎同时尝试访问Warehouse的资源，由于lock()方法不会响应中断，因此即使一个线程在持有锁时被中断，它也会继续执行直到释放锁。

这个代码输出内容如下，因为ReentrantLock确保了资源在任何时候只被一个线程访问，如下：

Thread-1 accessed the resource: Goods inside the warehouse  
Thread-2 accessed the resource: Goods inside the warehouse

使用lockInterruptibly()

下面使用Lock接口中的lockInterruptibly()方法的Java代码示例，演示如何中断一个正在等待获取锁的线程，如下代码：

import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
  
// 仓库类，使用Lock来控制访问  
public class Warehouse {  
    private final Lock lock = new ReentrantLock();  
    private String resource = "Goods inside the warehouse"; // 仓库中的资源  
  
    // 可响应中断地获取仓库资源的方法  
    public void accessResourceInterruptibly() throws InterruptedException {  
        lock.lockInterruptibly(); // 可响应中断地获取锁  
        try {  
            // 模拟长时间的操作  
            Thread.sleep(2000);  
            System.out.println(Thread.currentThread().getName() + " accessed the resource: " + resource);  
        } finally {  
            lock.unlock(); // 无论如何都会释放锁  
        }  
    }  
}  
  
// 客户端代码，模拟两个线程同时尝试访问仓库资源，并中断其中一个线程  
public class Client {  
    public static void main(String[] args) throws InterruptedException {  
        Warehouse warehouse = new Warehouse();  
  
        // 创建第一个线程并启动，它将尝试访问仓库资源  
        Thread thread1 = new Thread(() -> {  
            try {  
                warehouse.accessResourceInterruptibly();  
            } catch (InterruptedException e) {  
                System.out.println(Thread.currentThread().getName() + " was interrupted while waiting for the lock.");  
            }  
        }, "Thread-1");  
        thread1.start();  
  
        // 让第一个线程有时间去获取锁  
        Thread.sleep(500);  
  
        // 创建第二个线程，它也将尝试访问仓库资源，但会中断它  
        Thread thread2 = new Thread(() -> {  
            try {  
                warehouse.accessResourceInterruptibly();  
            } catch (InterruptedException e) {  
                System.out.println(Thread.currentThread().getName() + " was interrupted while waiting for the lock.");  
            }  
        }, "Thread-2");  
        thread2.start();  
  
        // 中断第二个线程，因为它可能正在等待获取锁  
        Thread.sleep(500);  
        thread2.interrupt();  
  
        // 等待第一个线程完成  
        thread1.join();  
    }  
}

在上面代码中，Warehouse类有一个accessResourceInterruptibly方法，它使用lockInterruptibly()方法来获取锁，如果线程在等待获取锁的过程中被中断，它将抛出InterruptedException异常。

在Client类的main方法中，创建了两个线程，第一个线程（thread1）启动后，让它先运行一段时间以确保它能够获取到锁，然后，启动第二个线程（thread2），并立即中断它，由于thread2在调用lockInterruptibly()时可能会被中断，因此它应该捕获InterruptedException并打印出一条消息，表明它在等待锁的过程中被中断了。

输出如下：

Thread-1 accessed the resource: Goods inside the warehouse  
Thread-2 was interrupted while waiting for the lock.

这个输出表明thread1成功访问了资源，而thread2则在等待获取锁的过程中被中断了。

核心总结

1、使用lock方法的情况：

当需要确保一段代码或一系列操作以原子方式执行，即在这段代码执行期间不会被其他线程干扰时，可以使用lock方法，lock方法会尝试获取锁，如果锁当前被其他线程持有，那么当前线程将被挂起（即阻塞），直到锁变得可用，这是一种基本的线程同步机制，用于防止多个线程同时访问共享资源，从而避免数据不一致和其他并发问题。

2、使用lockInterruptibly方法的情况：

与lock方法类似，lockInterruptibly方法也用于获取锁以保护临界区，但是，lockInterruptibly有一个额外的特性：它是可响应中断的，这意味着，如果当前线程在等待获取锁的过程中被中断（例如，通过调用Thread.interrupt方法），lockInterruptibly将不会无限期地等待下去，而是会立即抛出InterruptedException异常，这使得线程能够更灵活地处理中断，例如，可以在被中断时执行一些清理操作或通知其他线程。

3、总结：

如果需要确保代码块的原子性，并且不关心线程是否能够在等待锁时被中断，那么可以使用lock方法，但是，如果希望线程在等待锁时能够响应中断，那么应该使用lockInterruptibly方法。在处理可能被中断的长时间操作或需要更细粒度的中断控制时，lockInterruptibly通常是一个更好的选择。