干货,深入剖析ReentrantLock源码,推荐收藏
ReentrantLock和Synchronized都是Java开发中最常用的锁,与Synchronized这种JVM内置锁不同的是,ReentrantLock提供了更丰富的语义。可以创建公平锁或非公平锁、响应中断、超时等待、按条件唤醒等。在某些场景下,使用ReentrantLock更适合,功能更强大。
前两篇文章,我们分析了AQS的加锁流程、以及源码实现。当时我们就说了,AQS使用了模板设计模式,父类中定义加锁流程,子类去实现具体的加锁逻辑。所以大部分加锁代码已经在父类AQS中实现了,导致ReentrantLock的源码非常简单,一块学习一下。
先看一下ReentrantLock怎么使用?
1. ReentrantLock的使用
/**
* @author 一灯架构
* @apiNote ReentrantLock示例
**/
public class ReentrantLockDemo {
public static void main(String[] args) {
// 1. 创建ReentrantLock对象
ReentrantLock lock = new ReentrantLock();
// 2. 加锁
lock.lock();
try {
// 3. 这里执行具体的业务逻辑
} finally {
// 4. 释放锁
lock.unlock();
}
}
}
可以看到ReentrantLock的使用非常简单,调用lock加锁,unlock释放锁,需要配置try/finally使用,保证在代码执行出错的时候也能释放锁。
ReentrantLock也可以配合Condition条件使用,具体可以翻一下前几篇文章中BlockingQueue的源码解析,那里面有ReentrantLock的实际使用。
再看一下ReentrantLock的类结构
2. ReentrantLock类结构
// 实现Lock接口
public class ReentrantLock implements Lock {
// 只有一个Sync同步变量
private final Sync sync;
// Sync继承自AQS,主要逻辑都在这里面
abstract static class Sync extends AbstractQueuedSynchronizer {
}
// Sync的两个子类,分别实现了公平锁和非公平锁
static final class FairSync extends Sync {
}
static final class NonfairSync extends Sync {
}
}
可以看出ReentrantLock的类结构非常简单,实现了Lock接口。
类里面有两个静态内部类,分别实现公平锁和非公平锁。
看一下Lock接口中,定义了哪些方法?
public interface Lock {
// 加锁
void lock();
// 加可中断的锁
void lockInterruptibly() throws InterruptedException;
// 尝试加锁
boolean tryLock();
// 一段时间内,尝试加锁
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
// 释放锁
void unlock();
// 新建条件状态
Condition newCondition();
}
就是一些使用锁的常用方法。
在上篇文章中浏览AQS源码的时候,了解到AQS定义了一些有关具体加锁、释放锁的抽象方法,留给子类去实现,再看一下有哪些抽象方法:
// 加独占锁
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
// 释放独占锁
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
// 加共享锁
protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
}
// 释放共享锁
protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
}
// 判断是否是当前线程正在持有锁
protected boolean isHeldExclusively() {
throw new UnsupportedOperationException();
}
由于ReentrantLock使用的是独占锁,所以只需要实现独占锁相关的方法就可以了。
3. ReentrantLock源码解析
3.1 ReentrantLock构造方法
// 默认的构造方法,使用非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
// 传true,可以指定使用公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
在创建ReentrantLock对象的时候,可以指定使用公平锁还是非公平锁,默认使用非公平锁,显然非公平锁的性能更好。
先思考一个面试常考问题,公平锁和非公平锁是怎么实现的?
3.2 非公平锁源码
先看一下加锁源码:
从父类ReentrantLock的加锁方法入口:
public class ReentrantLock implements Lock {
// 加锁入口方法
public void lock() {
// 调用Sync中加锁方法
sync.lock();
}
}
在子类NonfairSync的加锁方法:
// 非公平锁
static final class NonfairSync extends Sync {
// 加锁
final void lock() {
// 1. 先尝试加锁(使用CAS设置state=1)
if (compareAndSetState(0, 1))
// 2. 加锁成功,就把当前线程设置为持有锁线程
setExclusiveOwnerThread(Thread.currentThread());
else
// 3. 没加锁成功,再调用父类AQS中实际的加锁逻辑
acquire(1);
}
}
加锁逻辑也很简单,先尝试使用CAS加锁(也就是把state从0设置成1),加锁成功,就把当前线程设置为持有锁线程。
设计者很聪明,在锁竞争不激烈的情况下,很大概率可以加锁成功,也就不用走else中复杂的加锁逻辑了。
如果没有加锁成功,还是需要走else中调用父类AQS的acquire方法,而acquire又需要调用子类的tryAcquire方法。
调用链路就是下面这样:
根据调用链路,实际的加锁逻辑在Sync.nonfairTryAcquire方法里面。
abstract static class Sync extends AbstractQueuedSynchronizer {
// 非公平锁的最终加锁方法
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
// 1. 获取同步状态
int c = getState();
// 2. state=0表示无锁,先尝试加锁(使用CAS设置state=1)
if (c == 0) {
if (compareAndSetState(0, acquires)) {
// 3. 加锁成功,就把当前线程设置为持有锁线程
setExclusiveOwnerThread(current);
return true;
}
// 4. 如果当前线程已经持有锁,执行可重入的逻辑
} else if (current == getExclusiveOwnerThread()) {
// 5. 加锁次数+acquires
int nextc = c + acquires;
// 6. 超过tnt类型最大值,溢出了
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
再看一下释放锁的调用流程,公平锁和非公平锁流程是一样的,最终都是执行Sync.tryRelease方法:
abstract static class Sync extends AbstractQueuedSynchronizer {
// 释放锁
protected final boolean tryRelease(int releases) {
// 1. 同步状态减去释放锁次数
int c = getState() - releases;
// 2. 校验当前线程不持有锁,就报错
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 3. 判断同步状态是否等于0,无锁后,就删除持有锁的线程
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
}
再看一下公平锁的源码
3.3 公平锁源码
先看一下公平锁的加锁流程:
最终的加锁方法是FairSync.tryAcquire,看一下具体逻辑:
static final class FairSync extends Sync {
// 实现父类的加锁逻辑
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
// 1. 获取同步状态
int c = getState();
// 2. state=0表示无锁,先尝试加锁(使用CAS设置state=1)
if (c == 0) {
// 3. 判断当前线程是不是头节点的下一个节点(讲究先来后到)
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
// 4. 如果当前线程已经持有锁,执行可重入的逻辑
} else if (current == getExclusiveOwnerThread()) {
// 5. 加锁次数+acquires
int nextc = c + acquires;
// 6. 超过tnt类型最大值,溢出了
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
// 判断当前线程是不是头节点的下一个节点(讲究先来后到)
public final boolean hasQueuedPredecessors() {
Node t = tail;
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}
}
公平锁的释放锁逻辑跟非公平锁一样,上面已经讲过。
4. 总结
看完了ReentrantLock的所有源码,是不是觉得ReentrantLock很简单。
由于加锁流程的编排工作已经在父类AQS中实现,子类只需要实现具体的加锁逻辑即可。
加锁逻辑也很简单,也就是修改同步状态state的值和持有锁的线程exclusiveOwnerThread。
我是「一灯架构」,如果本文对你有帮助,欢迎各位小伙伴点赞、评论和关注,感谢各位老铁,我们下期见
干货,深入剖析ReentrantLock源码,推荐收藏的更多相关文章
- Java并发系列[5]----ReentrantLock源码分析
在Java5.0之前,协调对共享对象的访问可以使用的机制只有synchronized和volatile.我们知道synchronized关键字实现了内置锁,而volatile关键字保证了多线程的内存可 ...
- 死磕 java同步系列之ReentrantLock源码解析(二)——条件锁
问题 (1)条件锁是什么? (2)条件锁适用于什么场景? (3)条件锁的await()是在其它线程signal()的时候唤醒的吗? 简介 条件锁,是指在获取锁之后发现当前业务场景自己无法处理,而需要等 ...
- Java并发编程笔记之ReentrantLock源码分析
ReentrantLock是可重入的独占锁,同时只能有一个线程可以获取该锁,其他获取该锁的线程会被阻塞后放入该锁的AQS阻塞队列里面. 首先我们先看一下ReentrantLock的类图结构,如下图所示 ...
- Java并发编程-ReentrantLock源码分析
一.前言 在分析了 AbstractQueuedSynchronier 源码后,接着分析ReentrantLock源码,其实在 AbstractQueuedSynchronizer 的分析中,已经提到 ...
- 第六章 ReentrantLock源码解析2--释放锁unlock()
最常用的方式: int a = 12; //注意:通常情况下,这个会设置成一个类变量,比如说Segement中的段锁与copyOnWriteArrayList中的全局锁 final Reentrant ...
- java多线程---ReentrantLock源码分析
ReentrantLock源码分析 基础知识复习 synchronized和lock的区别 synchronized是非公平锁,无法保证线程按照申请锁的顺序获得锁,而Lock锁提供了可选参数,可以配置 ...
- ReentrantLock源码分析--jdk1.8
JDK1.8 ArrayList源码分析--jdk1.8LinkedList源码分析--jdk1.8HashMap源码分析--jdk1.8AQS源码分析--jdk1.8ReentrantLock源码分 ...
- JUC AQS ReentrantLock源码分析
警告⚠️:本文耗时很长,先做好心理准备,建议PC端浏览器浏览效果更佳. Java的内置锁一直都是备受争议的,在JDK1.6之前,synchronized这个重量级锁其性能一直都是较为低下,虽然在1.6 ...
- java源码-ReentrantLock源码分析-1
ReentrantLock 继承于lock是比较常用的独占锁,接下来我们来分析一下ReentrantLock源码以及接口设计: Sync是ReentrantLock的内部静态抽象类继承Abstract ...
随机推荐
- 【java】学习路径19-Math类、BigDecimal的使用
1--Math类简单的东西 //一些常数 show(Math.PI); show(Math.E); //四舍五入 show(Math.round(3.4)); show(Math.round(3.6) ...
- C++ 性能小测 1 二维数组的遍历效率
C++ 性能小测 1 二维数组的遍历效率 遍历二维数组时,常规思路是使用一个嵌套循环.一方面,由于 CPU 使用了分支预测技术,因此通常将循环次数最多循环的放在最内层.另一方面,由于二维数组是按行存储 ...
- pathlib路径问题
下面是我的文件框架 app ------ file1---- .py1 file2---- .py2 config.py 我在config文件中设置了变量参数 BASE_DIR = pathlib.P ...
- 什么?MySQL 8.0 会同时修改两个ib_logfilesN 文件?
GreatSQL社区原创内容未经授权不得随意使用,转载请联系小编并注明来源. GreatSQL是MySQL的国产分支版本,使用上与MySQL一致. 作者介绍:孙黎,GreatDB 认证DBA 问题现象 ...
- 【读书笔记】C#高级编程 第七章 运算符和类型强制转换
(一)运算符 类别 运算符 算术运算符 + - * / % 逻辑运算符 & | ^ ~ && || ! 字符串连接运算符 + 增量和减量运算符 ++ -- 移位运算符 < ...
- ubuntu下vscode安装go插件失败解决办法
go env -w GO111MODULE=on go env -w GOPROXY=https://goproxy.io,direct go env -w GOSUMDB=gosum.io+ce6e ...
- filebeat读取超链接日志 symlinks
filebeat读取超链接日志文件,还需要增加配置上额外的参数:symlinks: true 符号链接选项允许Filebeat除常规文件外,可以收集符号链接.收集符号链接时,即使报告了符号链接的路径, ...
- linux中通过date命令获取昨天或明天时间的方法
date命令可以获取当前的时间,通过man,可以看到date有很多参数可以用,很容易做到格式化 # 获取当前日期 date +"%F" 或者 date +"%Y-%m-% ...
- CentOS无法识别NTFS格式U盘完美解决方案
问题描述:CentOS上无法识别NTFS格式的U盘 解决方案: # 进入yum目录 cd /etc/yum.repos.d # 下载阿里的epel wget http://mirrors.aliyun ...
- MongoDB分片集群-Sharded Cluster
分片概念 分片(sharding)是一种跨多台机器分布数据的方法, MongoDB使用分片来支持具有非常大的数据集和高吞吐量操作的部署. 换句话说:分片(sharding)是指将数据拆分,将其分散存在 ...