Lock
前面聊了聊 synchronized，今天再聊聊 Lock。Lock 接口是 Java 5 引入的，最常见的实现类是 ReentrantLock、ReadLock、WriteLock，可以起到 “锁” 的作用。
PS：篇幅原因，这章不聊实现类，后面再聊，只专注于 Lock 以及它与 synchronized 的区别。
![]()
Lock.png
Lock 和 synchronized 是 java 中两种最常见的锁，"锁" 是一种工具。它用于控制对共享资源的访问。需要注意的是 Lock 设计的初衷并不是为了取代 synchronized ，而是一种升级。当 synchronized 不合适或者不能满足需求时（后面会说两者区别），Lock 顶上。
一般情况下，Lock 同一时间只允许一个线程来访问这个共享资源。但是也有特殊的时候允许并发访问。比如读写锁（ReadWriteLock）里面的读锁（ReadLock）。PS：这就是其中一个 synchronized 不能满足的场景。
Lock 的方法
如下图所示，Lock 有 5 个方法，1 个条件：
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();
}
lock 加锁主要有 4 个方法：lock、lockInterruptibly、tryLock、tryLock (long time, TimeUnit unit) 。解锁只有一个 unlock 方法。此外，还有一个线程间通信的条件（Condition）。下面逐一讲解：
lock
Lock 有 4 种加锁方法，其中 lock 是最基础的。Lock 获取锁和释放锁都是显式的，不像 synchronized 是隐式的。所以 synchronized 会在抛异常时自动释放锁，而 Lock 只能是主动释放，加解锁都必须有显式的代码控制。所以就有了以下伪代码：
Lock lock = ...;
// 代码显式加锁
lock.lock();
try {
//获取到了被本锁保护的资源，处理任务
//捕获异常
} finally {
//代码显式释放锁
lock.unlock();
}
这种 lock 的写法才是最安全的，先获取 lock，然后在 try 中操作资源，最后 finally 中释放锁，以保证绝对释放（这一步非常重要，它防止代码走不到这里，导致跳过了 unlock () 语句，使得这个锁永远不能被释放）。
此外，lock () 方法有个缺点就是它不能被中断，一旦陷入死锁，lock () 就会陷入永久等待。所以，一般来说我们会用 tryLock 来代替 lock。
tryLock
tryLock 顾名思义是尝试获取锁的意思，返回值是 boolean，获取成功返回 true，获取失败返回 false*。使用方法如下：
Lock lock = ...;
if (lock.tryLock()) {
try {
//操作资源
} finally {
//释放锁
lock.unlock();
}
} else {
//如果不能获取锁，则做其他事情
}
使用 if 判断是否获取锁，成功获取则去操作共享资源，失败则去干别的事（比如，几秒之后重试，或者跳过此任务），最后还是记得要在 finally 中释放锁。
tryLock 解决死锁问题
想象这样一个场景：比如有两个线程同时调用以下这个方法，传入的 lock1 和 lock2 恰好是相反的。如果第一个线程获取了 lock1，第二个线程获取了 lock2，两个线程都需要获取对方的锁才能工作。如果用 lock 这就很容易陷入死锁，原因前面也说了。
这个时候 tryLock 就发挥作用了：其中一个线程尝试获取锁 lock1，获取不到，则去隔段时间重试（这样做的目的在于等另一个获取到锁的线程在这段时间内完成任务，释放锁）。获取到了，则继续获取 lock2 ，获取到就操作共享资源，获取不到则释放 lock1，继续进入重试。
public void tryLock(Lock lock1, Lock lock2) throws InterruptedException {
while (true) {
if (lock1.tryLock()) {
try {
if (lock2.tryLock()) {
try {
System.out.println("获取到了两把锁，完成业务逻辑");
return;
} finally {
lock2.unlock();
}
}
} finally {
lock1.unlock();
}
} else {
Thread.sleep(new Random().nextInt(1000));
}
}
}
tryLock(long time, TimeUnit unit)
这个方法是 tryLock 的重载，区别在于 tryLock (long time, TimeUnit unit) 方法会有一个超时时间。在拿不到锁时会等待指定的时间，在指定时间内获取不到锁返回 false；获取到锁或者等待期间内获取到锁，返回 true。
此外，超时之后，它将放弃主动获取锁。它还可以响应中断，抛出 InterruptException，避免死锁的产生。
lockInterruptibly
lockInterruptibly 去获取锁，获取到了马上返回 true。它非常执拗，如果获取不到锁就会一直尝试获取直到获取到为止，除非当前线程在获取锁期间被中断。可以把它理解为不限时的 tryLock (long time, TimeUnit unit)。
public void lockInterruptibly() throws InterruptException {
lock.lockInterruptibly();
try {
System.out.println("操作资源");
} finally {
lock.unlock();
}
}
unlock
unlock 顾名思义就是释放锁。就 ReentrantLock 而言，调用 unlock 方法时，内部会把锁的 “被持有计数器” 减 1，减到 0 代表当前线程已经完全释放这把锁。
newCondition()
Condition 的用法就不说了，不会的看之前这篇文章：线程之生产者消费者模式。它有两个主要的方法 await 和 signal 分别用于阻塞线程和唤醒线程。对应于 Object 的 wait 和 notify。
