多线程系列(九) -ReentrantLock常用方法详解
一、简介
在上一篇文章中，我们介绍了ReentrantLock类的一些基本用法，今天我们重点来介绍一下ReentrantLock其它的常用方法，以便对ReentrantLock类的使用有更深入的理解。
二、常用方法介绍
2.1、构造方法
ReentrantLock类有两个构造方法，核心源码内容如下：
/**
* 默认创建非公平锁
*/
public ReentrantLock() {
sync = new NonfairSync();
}
/**
* fair为true表示是公平锁，fair为false表示是非公平锁
*/
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
相比于synchronized同步锁，ReentrantLock有一个很大的特点，就是开发人员可以手动指定采用公平锁机制还是非公平锁机制。
公平锁：顾名思义，就是每个线程获取锁的顺序是按照线程排队的顺序来分配的，最前面的线程总是最先获取到锁。
- 优点：所有的线程都有机会得到资源
- 缺点：公平锁机制实现比较复杂，程序流程比较多，执行速度比较慢
非公平锁：每个线程获取锁的顺序是随机的，并不会遵循先来先得的规则，任何线程在某时刻都有可能直接获取并拥有锁，之前介绍的synchronized其实就是一种非公平锁
- 优点：公平锁机制实现相对比较简单，程序流程比较少，执行速度比较快
- 缺点：有可能某些线程一直拿不到锁，导致饿死
ReentrantLock默认的构造方法是非公平锁，如果想要构造公平锁机制，只需要传入true就可以了。
示例代码如下：
public static void main(String[] args) {
// 创建公平锁实现机制
Lock lock = new ReentrantLock(true);
// 创建5个线程
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 启动了!");
// 尝试获取锁
lock.lock();
try {
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 获得锁!");
} finally {
lock.unlock();
}
}
}).start();
}
}
运行一下程序，结果如下：
ThreadName：Thread-0, 启动了!
ThreadName：Thread-1, 启动了!
ThreadName：Thread-0, 获得锁!
ThreadName：Thread-1, 获得锁!
ThreadName：Thread-2, 启动了!
ThreadName：Thread-2, 获得锁!
ThreadName：Thread-3, 启动了!
ThreadName：Thread-3, 获得锁!
ThreadName：Thread-4, 启动了!
ThreadName：Thread-4, 获得锁!
从日志上可以看到，启动顺序为0,1,2,3,4，获取锁的顺序为0,1,2,3,4，启动与获取锁的排队机制一致。
假如我们构造方法里面的把true改成false，也就是非公平锁机制，在看看运行效果，结果如下：
ThreadName：Thread-1, 启动了!
ThreadName：Thread-2, 启动了!
ThreadName：Thread-1, 获得锁!
ThreadName：Thread-0, 启动了!
ThreadName：Thread-2, 获得锁!
ThreadName：Thread-3, 启动了!
ThreadName：Thread-3, 获得锁!
ThreadName：Thread-0, 获得锁!
ThreadName：Thread-4, 启动了!
ThreadName：Thread-4, 获得锁!
从日志上可以看到，启动顺序为1,2,0,3,4，获取锁的顺序为1,2,3,0,4，线程启用与获取锁的顺序不一致。
从实际的运行结果看，非公平锁要比公平锁执行速度要快一些，当线程数越多的时候，效果越明显。
2.2、核心方法
ReentrantLock类的核心方法就比较多了，如下表！
| 方法 | 描述 |
|---|---|
| public void lock() | 阻塞等待获取锁；不允许Thread.interrupt中断，即使检测到Thread.isInterrupted一样会继续尝试 |
| public void lockInterruptibly() | 当前线程未被中断，则获取锁；允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回 |
| public boolean tryLock() | 尝试申请一个锁，在成功获得锁后返回true，否则，立即返回false |
| public boolean tryLock(long timeout, TimeUnit unit) | 在一段时间内尝试申请一个锁，在成功获得锁后返回true，否则，立即返回false |
| public void unlock() | 释放锁 |
| public Condition newCondition() | 条件实例，用于线程等待/通知模式 |
| public int getHoldCount() | 获取当前线程持有此锁的次数 |
| public boolean isHeldByCurrentThread() | 检测是否被当前线程持有 |
| public boolean isLocked() | 查询此锁是否由任意线程持有 |
| public final boolean isFair() | 如果是公平锁返回true，否则返回false |
| public final boolean hasQueuedThreads() | 查询是否有线程正在等待 |
| public final boolean hasQueuedThread(Thread thread) | 查询给定线程是否正在等待获取此锁 |
| public final int getQueueLength() | 获取正等待获取此锁的线程数 |
| public boolean hasWaiters(Condition condition) | 是否存在正在等待并符合相关给定条件的线程 |
| public int getWaitQueueLength(Condition condition) | 正在等待并符合相关给定条件的线程数量 |
虽然方法很多，但是实际上常用方法就那么几个，下面我们主要抽一些常用的方法进行介绍。
2.2.1、tryLock 方法
lock()、lockInterruptibly()、tryLock()和tryLock(long timeout, TimeUnit unit)这几个方法，目的其实是一样的，都是为了获取锁，只是针对不同的场景做了单独的处理。
lock()：阻塞等待获取锁，如果没有获取到会一直阻塞，即使检测到Thread.isInterrupted一样会继续尝试；
lockInterruptibly()：同样也是阻塞等待获取锁，稍有不同的是，允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回tryLock()：表示尝试申请一个锁，在成功获得锁后返回true，否则，立即返回false，不会阻塞等待获取锁tryLock(long timeout, TimeUnit unit)：表示在一段时间内尝试申请一个锁，在成功获得锁后返回true，否则，立即返回false
其中tryLock(long timeout, TimeUnit unit)方法的应用最广泛，因为它能防止程序发生死锁，即使在一段时间内没有获取锁，也会自动退出，不会一直阻塞。
我们可以看一个简单的例子，如下！
public static void main(String[] args) {
// 创建公平锁实现机制
Lock lock = new ReentrantLock();
// 创建5个线程
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
boolean flag = false;
try {
// 尝试3秒内获取锁
flag = lock.tryLock(3, TimeUnit.SECONDS);
if(flag){
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 获取到锁");
// 模拟进行5秒的业务操作
Thread.sleep(5000);
} else {
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 经过3秒钟的尝试未获取到锁，放弃尝试");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (flag){
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 释放对象");
lock.unlock();
}
}
}
}).start();
}
}
运行一下程序，结果如下：
ThreadName：Thread-0, 获取到锁
ThreadName：Thread-3, 经过3秒钟的尝试未获取到锁，放弃尝试
ThreadName：Thread-1, 经过3秒钟的尝试未获取到锁，放弃尝试
ThreadName：Thread-2, 经过3秒钟的尝试未获取到锁，放弃尝试
ThreadName：Thread-4, 经过3秒钟的尝试未获取到锁，放弃尝试
ThreadName：Thread-0, 释放对象
可以很清晰的看到，非Thread-0线程尝试了 3 秒没有获取到锁，自动放弃；如果换成lock()方法进行获取锁，线程Thread-0如果不释放锁，其它线程会一直阻塞。
2.2.2、unlock 方法
unlock()方法也是常用方法，表示释放锁。当获取到锁之后，一定要手动释放锁，否则可能会造成其它程序执行出现问题，通常用在finally方法块里面。
// 阻塞等待获取锁
lock.lock();
try {
// 业务操作...
} finally {
// 一定要释放锁
lock.unlock();
}
2.2.3、newCondition 方法
newCondition()方法，在上文中介绍过，ReentrantLock和Condition结合，可以实现线程之间的等待／通知模型。
简单的示例，如下！
public class Counter {
private final Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
private int count;
public void await(){
// 加锁
lock.lock();
try {
// 让当前线程进入等待状态，并释放锁
condition.await();
System.out.println("await等待结束，count：" + getCount());
} catch (Exception e){
e.printStackTrace();
} finally {
// 释放锁
lock.unlock();
}
}
public void signal(){
// 加锁
lock.lock();
try {
count++;
// 唤醒某个等待线程
condition.signal();
System.out.println("signal 唤醒通知完毕");
} catch (Exception e){
e.printStackTrace();
} finally {
// 释放锁
lock.unlock();
}
}
public int getCount() {
return count;
}
}
public class MyThreadTest {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
// 先启动执行等待的线程
new Thread(new Runnable() {
@Override
public void run() {
counter.await();
}
}).start();
Thread.sleep(3000);
// 过3秒，再启动执行通知的线程
new Thread(new Runnable() {
@Override
public void run() {
counter.signal();
}
}).start();
}
}
运行一下程序，结果如下：
signal 唤醒通知完毕
await等待结束，count：1
2.2.4、getHoldCount 方法
getHoldCount()方法的作用是返回的是当前线程调用lock()的次数。
示例代码如下：
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
new Thread(new Runnable() {
@Override
public void run() {
// 第一次获取锁
lock.lock();
try {
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", getHoldCount：" + lock.getHoldCount());
// 第二次获取锁
lock.lock();
try {
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", getHoldCount：" + lock.getHoldCount());
} finally {
lock.unlock();
}
} finally {
lock.unlock();
}
}
}).start();
}
运行一下程序，结果如下：
ThreadName：Thread-0, getHoldCount：1
ThreadName：Thread-0, getHoldCount：2
侧面也证明了一点，ReentrantLock和synchronized一样，锁都具有可重入特性，也就是说同一个线程多次调用同一个ReentrantLock的lock()方法，可以再次进入方法体，无需阻塞等待。
2.2.5、isLocked 方法
isHeldByCurrentThread()和isLocked()方法都是用于检测锁是否被持有。
其中isHeldByCurrentThread()方法表示此锁是否由当前线程持有；isLocked()方法表示此锁是否由任意线程持有。
我们看一个简单的示例，如下：
public class Counter {
private ReentrantLock lock = new ReentrantLock();
public void methodA(){
lock.lock();
try {
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 当前线程是否持有锁:" + lock.isHeldByCurrentThread());
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 任意线程是否持有锁:" + lock.isLocked());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void methodB(){
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 当前线程是否持有锁:" + lock.isHeldByCurrentThread());
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 任意线程是否持有锁:" + lock.isLocked());
}
}
public class MyThreadTest {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
new Thread(new Runnable() {
@Override
public void run() {
counter.methodA();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
counter.methodB();
}
}).start();
}
}
运行一下程序，结果如下：
ThreadName：Thread-0, 当前线程是否持有锁:true
ThreadName：Thread-0, 任意线程是否持有锁:true
ThreadName：Thread-1, 当前线程是否持有锁:false
ThreadName：Thread-1, 任意线程是否持有锁:true
从日志结果很容易理解，Thread-0线程持有锁，因此调用isHeldByCurrentThread()和isLocked()方法，返回结果都是true；Thread-1线程没有持有锁，因此isHeldByCurrentThread()方法返回false，isLocked()方法返回true
2.2.6、isFair 方法
isFair()方法用来获取此锁是否公平锁。
简单的示例，如下：
ReentrantLock lock = new ReentrantLock(true);
System.out.println("是否公平锁:" + lock.isFair());
输出结果如下：
是否公平锁:true
ReentrantLock默认的是非公平锁，当通过构造方法显式传入true时，采用的是公平锁机制
2.2.5、hasQueuedThreads 方法
hasQueuedThreads()和hasQueuedThread()方法都用于查询是否有线程等待获取锁，稍有不同的是：hasQueuedThreads()方法表示查询是否有线程正在等待获取锁；hasQueuedThread()方法表示查询给定线程是否正在等待获取此锁。
另外还有一个getQueueLength()方法，表示获取正等待获取此锁的线程数。
我们看一个简单的示例，如下：
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
});
threadA.start();
Thread threadB = new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
});
threadB.start();
// 等待线程都启动完毕
Thread.sleep(1000);
System.out.println("查询是否有线程正在等待：" + lock.hasQueuedThreads());
System.out.println("查询处于等待的线程数：" + lock.getQueueLength());
System.out.println("threadA 是否处于等待状态：" + lock.hasQueuedThread(threadA));
System.out.println("threadB 是否处于等待状态：" + lock.hasQueuedThread(threadB));
}
输出结果如下：
查询是否有线程正在等待：true
查询处于等待的线程数：1
threadA 是否处于等待状态：false
threadB 是否处于等待状态：true
从日志上可以清晰的看到，线程threadA先获取了锁，线程threadB处于等待获取锁的状态，处于等待的线程数为1。
2.2.7、hasWaiters 方法
hasWaiters()和getWaitQueueLength()方法，支持传入condition条件对象进行查询。
其中hasWaiters()方法表示查询是否存在正在等待并符合相关给定条件的线程；getWaitQueueLength()方法表示查询正在等待并符合相关给定条件的线程数量。
我们看一个简单的示例，如下：
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
try {
condition.await();
System.out.println("await等待结束");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
});
threadA.start();
// 睡眠1秒
Thread.sleep(1000);
Thread threadB = new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
try {
System.out.println("是否存在正在等待并符合相关给定条件的线程：" + lock.hasWaiters(condition));
System.out.println("正在等待并符合相关给定条件的线程数量：" + lock.getWaitQueueLength(condition));
Thread.sleep(5000);
condition.signal();
System.out.println("signal 唤醒通知完毕");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
});
threadB.start();
}
输出结果如下：
是否存在正在等待并符合相关给定条件的线程：true
正在等待并符合相关给定条件的线程数量：1
signal 唤醒通知完毕
await等待结束
需要注意的是，调用condition对象的方法，必须要在获取锁的方法体内执行。
三、小结
本文主要围绕ReentrantLock类的核心方法进行了一些知识总结，其中最常用方法的主要就两个，tryLock(long timeout, TimeUnit unit)和unlock()，通过它可以实现线程同步安全的效果。
本文内容比较多，如果有不正之处，请多多谅解，并欢迎批评指出。
