Java11中的Lock接口提供
lock()和lockInterruptibly()两种锁定方法，用于获取锁，但处理线程中断时有所不同，lock()使线程等待直到锁释放，期间无视中断；而lockInterruptibly()在等待中若收到中断请求，会立即响应并抛出异常，这种机制使lockInterruptibly()更灵活，能更好处理线程中断，避免无意义等待，提升系统响应性和效率。
定义
在Java 11中，Lock接口提供了两种锁定方法：lock()和lockInterruptibly()，这两种方法虽然都是为了获取锁，但在处理线程中断时有着显著的不同。
lock()方法是一种基本的锁定机制，当一个线程调用这个方法时，如果锁已经被其他线程持有，那么调用线程就会进入等待状态，直到锁被释放，在等待的过程中，这个线程会无视中断请求，也就是说，即使有其他线程调用了这个等待线程的interrupt()方法，它也不会有任何响应，依旧会“执着”地等待锁的释放。
而lockInterruptibly()方法则不同，它提供了一种更加“灵活”的锁定机制，当一个线程调用这个方法时，如果锁已经被其他线程持有，那么这个线程同样会进入等待状态，但是，在等待的过程中，如果这个线程收到了中断请求（即有其他线程调用了它的interrupt()方法），那么它就会立即响应中断，不再等待锁的释放，而是抛出一个InterruptedException异常。
举个例子来说明这两种方法的区别，假设有一个仓库，只有一把钥匙可以打开（这里把钥匙比作锁），现在有两个人（线程）都想进入仓库取东西，
- 如果第一个人使用
lock()方法，那么在他拿到钥匙并进入仓库之前，即使有人叫他（发送中断请求），他也不会理睬，直到他取完东西出来并把钥匙交给下一个人。 - 如果第一个人使用
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通常是一个更好的选择。
