它的子类列表如下：
我们通常会使用 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常见的坑有哪些的详细内容。