ReentrantLock 中的 4 个坑！

作者 | 王磊

来源 | Java中文社群（ID：javacn666）

转载请联系授权（微信ID：GG_Stone）

JDK 1.5 之前 synchronized 的性能是比较低的，但在 JDK 1.5 中，官方推出一个重量级功能 Lock，一举改变了 Java 中锁的格局。JDK 1.5 之前当我们谈到锁时，只能使用内置锁 synchronized，但如今我们锁的实现又多了一种显式锁 Lock。

前面的文章我们已经介绍了 synchronized，详见以下列表：

《synchronized 加锁 this 和 class 的区别！》

《synchronized 优化手段之锁膨胀机制！》

《synchronized 中的 4 个优化，你知道几个？》

所以本文咱们重点来看 Lock。

Lock 简介

Lock 是一个顶级接口，它的所有方法如下图所示：

它的子类列表如下：

我们通常会使用 ReentrantLock 来定义其实例，它们之间的关联如下图所示：

“

PS：Sync 是同步锁的意思，FairSync 是公平锁，NonfairSync 是非公平锁。

ReentrantLock 使用

学习任何一项技能都是先从使用开始的，所以我们也不例外，咱们先来看下 ReentrantLock 的基础使用：

public class LockExample {// 创建锁对象private final ReentrantLock lock = new ReentrantLock();public void method() {// 加锁操作lock.lock();try {// 业务代码......} finally {// 释放锁lock.unlock();}}
}

ReentrantLock 在创建之后，有两个关键性的操作：

加锁操作：lock()
释放锁操作：unlock()

ReentrantLock 中的坑

1.ReentrantLock 默认为非公平锁

很多人会认为（尤其是新手朋友），ReentrantLock 默认的实现是公平锁，其实并非如此，ReentrantLock 默认情况下为非公平锁（这主要是出于性能方面的考虑），比如下面这段代码：

import java.util.concurrent.locks.ReentrantLock;public class LockExample {// 创建锁对象private static final ReentrantLock lock = new ReentrantLock();public static void main(String[] args) {// 定义线程任务Runnable runnable = new Runnable() {@Overridepublic void run() {// 加锁lock.lock();try {// 打印执行线程的名字System.out.println("线程:" + Thread.currentThread().getName());} finally {// 释放锁lock.unlock();}}};// 创建多个线程for (int i = 0; i < 10; i++) {new Thread(runnable).start();}}
}

以上程序的执行结果如下：

从上述执行的结果可以看出，ReentrantLock 默认情况下为非公平锁。因为线程的名称是根据创建的先后顺序递增的，所以如果是公平锁，那么线程的执行应该是有序递增的，但从上述的结果可以看出，线程的执行和打印是无序的，这说明 ReentrantLock 默认情况下为非公平锁。

想要将 ReentrantLock 设置为公平锁也很简单，只需要在创建 ReentrantLock 时，设置一个 true 的构造参数就可以了，如下代码所示：

import java.util.concurrent.locks.ReentrantLock;public class LockExample {// 创建锁对象(公平锁)private static final ReentrantLock lock = new ReentrantLock(true);public static void main(String[] args) {// 定义线程任务Runnable runnable = new Runnable() {@Overridepublic void run() {// 加锁lock.lock();try {// 打印执行线程的名字System.out.println("线程:" + Thread.currentThread().getName());} finally {// 释放锁lock.unlock();}}};// 创建多个线程for (int i = 0; i < 10; i++) {new Thread(runnable).start();}}
}

以上程序的执行结果如下：

从上述结果可以看出，当我们显式的给 ReentrantLock 设置了 true 的构造参数之后，ReentrantLock 就变成了公平锁，线程获取锁的顺序也变成有序的了。

其实从 ReentrantLock 的源码我们也可以看出它究竟是公平锁还是非公平锁，ReentrantLock 部分源码实现如下：

 public ReentrantLock() {sync = new NonfairSync();}
public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();
}

从上述源码中可以看出，默认情况下 ReentrantLock 会创建一个非公平锁，如果在创建时显式的设置构造参数的值为 true 时，它就会创建一个公平锁。

2.在 finally 中释放锁

使用 ReentrantLock 时一定要记得释放锁，否则就会导致该锁一直被占用，其他使用该锁的线程则会永久的等待下去，所以我们在使用 ReentrantLock 时，一定要在 finally 中释放锁，这样就可以保证锁一定会被释放。

反例

import java.util.concurrent.locks.ReentrantLock;public class LockExample {// 创建锁对象private static final ReentrantLock lock = new ReentrantLock();public static void main(String[] args) {// 加锁操作lock.lock();System.out.println("Hello,ReentrantLock.");// 此处会报异常,导致锁不能正常释放int number = 1 / 0;// 释放锁lock.unlock();System.out.println("锁释放成功!");}
}

以上程序的执行结果如下：

从上述结果可以看出，当出现异常时锁未被正常释放，这样就会导致其他使用该锁的线程永久的处于等待状态。

正例

import java.util.concurrent.locks.ReentrantLock;public class LockExample {// 创建锁对象private static final ReentrantLock lock = new ReentrantLock();public static void main(String[] args) {// 加锁操作lock.lock();try {System.out.println("Hello,ReentrantLock.");// 此处会报异常int number = 1 / 0;} finally {// 释放锁lock.unlock();System.out.println("锁释放成功!");}}
}

以上程序的执行结果如下：

从上述结果可以看出，虽然方法中出现了异常情况，但并不影响 ReentrantLock 锁的释放操作，这样其他使用此锁的线程就可以正常获取并运行了。

3.锁不能被释放多次

lock 操作的次数和 unlock 操作的次数必须一一对应，且不能出现一个锁被释放多次的情况，因为这样就会导致程序报错。

反例

一次 lock 对应了两次 unlock 操作，导致程序报错并终止执行，示例代码如下：

import java.util.concurrent.locks.ReentrantLock;public class LockExample {// 创建锁对象private static final ReentrantLock lock = new ReentrantLock();public static void main(String[] args) {// 加锁操作lock.lock();// 第一次释放锁try {System.out.println("执行业务 1~");// 业务代码 1......} finally {// 释放锁lock.unlock();System.out.println("锁释锁");}// 第二次释放锁try {System.out.println("执行业务 2~");// 业务代码 2......} finally {// 释放锁lock.unlock();System.out.println("锁释锁");}// 最后的打印操作System.out.println("程序执行完成.");}
}

以上程序的执行结果如下：

从上述结果可以看出，执行第 2 个 unlock 时，程序报错并终止执行了，导致异常之后的代码都未正常执行。

4.lock 不要放在 try 代码内

在使用 ReentrantLock 时，需要注意不要将加锁操作放在 try 代码中，这样会导致未加锁成功就执行了释放锁的操作，从而导致程序执行异常。

反例

import java.util.concurrent.locks.ReentrantLock;public class LockExample {// 创建锁对象private static final ReentrantLock lock = new ReentrantLock();public static void main(String[] args) {try {// 此处异常int num = 1 / 0;// 加锁操作lock.lock();} finally {// 释放锁lock.unlock();System.out.println("锁释锁");}System.out.println("程序执行完成.");}
}

以上程序的执行结果如下：

从上述结果可以看出，如果将加锁操作放在 try 代码中，可能会导致两个问题：

未加锁成功就执行了释放锁的操作，从而导致了新的异常；
释放锁的异常会覆盖程序原有的异常，从而增加了排查问题的难度。

总结

本文介绍了 Java 中的显式锁 Lock 及其子类 ReentrantLock 的使用和注意事项，Lock 在 Java 中占据了锁的半壁江山，但在使用时却要注意 4 个问题：

默认情况下 ReentrantLock 为非公平锁而非公平锁；
加锁次数和释放锁次数一定要保持一致，否则会导致线程阻塞或程序异常；
加锁操作一定要放在 try 代码之前，这样可以避免未加锁成功又释放锁的异常；
释放锁一定要放在 finally 中，否则会导致线程阻塞。

文末福利

今天恰好情人节磊哥联合博文视点出版社，给大家送 3 本何海涛老师的经典书籍《剑指Offer（专项突破版）：数据结构与算法名企面试题精讲》，作者从微软起步，面遍各国际大公司，且有近 20 年名企面试官经历，担任面试官面试千余次，积累大量真实试题和现场经验。

中奖规则：评论区留的第 6、16、26 位用户送出此书，免费包邮到家，下周二开奖。

当然，土豪朋友也可以通过下面连接直接购买。

本系列原创文章推荐

1.线程的故事：我的3位母亲成就了优秀的我！

2.线程池的7种创建方式，强烈推荐你用它...

3.轻量级锁一定比重量级锁快吗？

4.这样终止线程，竟然会导致服务宕机？

5.漫画：如何证明sleep不释放锁，而wait释放锁？

6.池化技术到达有多牛？看了这个对比吓我一跳！

7.求求你，别再用wait和notify了！

8.Semaphore自白：限流器用我就对了！

9.CountDownLatch：别浪，等人齐再团！

10.CyclicBarrier：人齐了，老司机就发车了！

11.Java中用户线程和守护线程区别这么大？

12.ThreadLocal不好用？那是你没用对！

13.ThreadLocal内存溢出代码演示和原因分析！

14.SimpleDateFormat线程不安全的5种解决方案！

15.synchronized 加锁 this 和 class 的区别！

16.synchronized 优化手段之锁膨胀机制！

17.synchronized 中的 4 个优化，你知道几个？