Java中ReentrantLock常见的坑有哪些

这篇文章主要介绍“Java中ReentrantLock常见的坑有哪些”，在日常操作中，相信很多人在Java中ReentrantLock常见的坑有哪些问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Java中ReentrantLock常见的坑有哪些”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

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() {            @Override            public 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() {            @Override            public 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中ReentrantLock常见的坑有哪些”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注编程网网站，小编会继续努力为大家带来更多实用的文章！