Java源码分析系列笔记-6.ReentrantLock
1. 是什么
在jdk5之前，synchronized效率极低，于是写了ReentranLock代替。
后来jdk7优化了synchronized，参考Java源码分析系列笔记-2.锁的优化 - ThinkerQAQ - 博客园。两者性能区别不大
1.1. synchronized vs ReentranLock
| 比较 | Synchronized | ReentrantLock |
|---|---|---|
| 等待 | 结合object wait/notify | 结合condition await/signal |
| 使用难度 | 简单。jvm会处理加锁，解锁的过程 | 麻烦。需要手动lock、unlock，且unlock得放在finally块中 |
| 特性 | 可重入 不可中断 非公平 | 可重入 可中断 可公平 |
| 实现原理 | monitor | AQS |
2. 实现原理
2.1. uml图
由uml图可以看出ReentranLock底层是用AQS实现的，有一个Sync属性（继承AQS类），如果是非公平锁则用的NonfairSync实现类，否则用的FairSync类
具体的实现参考
3. 公平锁
所谓公平锁，遵循先到先得的原则。
即使锁已经被释放了，后到的也不能去抢占锁，得等到前面没人时才能去获取
3.1. 如何使用
public class TestReentrantLock
{
private static int val = 0;
private final static Lock lock = new ReentrantLock(true);//公平锁
public static void main(String[] args) throws InterruptedException
{
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 100000; i++)
{
try
{
lock.lock();
val++;
}
finally
{
lock.unlock();
}
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 100000; i++)
{
try
{
lock.lock();
val--;
}
finally
{
lock.unlock();
}
}
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println(val);
}
}
3.2. 原理分析
3.2.1. 构造方法
3.2.1.1. 底层使用AQS实现
public class ReentrantLock implements Lock, java.io.Serializable {
private final Sync sync;
//默认非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
//true的话，公平锁使用FairSync，否则是NonfairSync
sync = fair ? new FairSync() : new NonfairSync();
}
//Sync是AQS的子类
abstract static class Sync extends AbstractQueuedSynchronizer {}
//FairSync是Sync的子类
static final class FairSync extends Sync {}
}
3.2.2. 加锁
- lock
public void lock() {
//调用FairSync的lock
sync.lock();
}
3.2.2.1. 调用公平锁的lock方法
- FairSync.lock
final void lock() {
//调用AQS的acquire
acquire(1);
}
3.2.2.2. 调用AQS的acquire方法获取锁
- AQS.acquire
public final void acquire(int arg) {
//调用FairSync的tryAcquire获取锁
if (!tryAcquire(arg) &&
//获取锁失败加入AQS队列。并且死循环阻塞当前线程，等待唤醒继续获取锁
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
//恢复中断标记
selfInterrupt();
}
由于FairSync重写了AQS的tryAcquire方法，因此这里会调用FairSync的tryAcquire
其他的逻辑同5.AQS.md，下面只是简要说一下主要逻辑
3.2.2.3. 尝试获取锁【只有队头才允许抢占锁--公平锁】
- FairSync.tryAcquire
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
//锁尚未被获取
if (c == 0) {
//【公平锁】：队列中我的前面没人等待锁（队列为空或者我就是队列的队头）
if (!hasQueuedPredecessors() &&
//CAS设置state获取锁成功
compareAndSetState(0, acquires)) {
//设置持有锁的线程为当前线程
setExclusiveOwnerThread(current);
return true;
}
}
//锁已经被获取，且是当前线程，那么重入
else if (current == getExclusiveOwnerThread()) {
//增加state量
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
//获取锁失败返回false
return false;
}
3.2.2.4. 尝试获取锁失败加入阻塞队列
- AQS.addWaiter
private Node addWaiter(Node mode) {
//用当前线程、EXCLUSIVE模式构造节点
Node node = new Node(Thread.currentThread(), mode);
// 队列不为空
Node pred = tail;
if (pred != null) {
//插入到队尾
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//队列为空或者插入到队尾失败
enq(node);
return node;
}
3.2.2.4.1. 入队的操作
- enq
private Node enq(final Node node) {
//死循环直到入队成功
for (;;) {
Node t = tail;
//队列为空，那么初始化头节点。注意是new Node而不是当前node（即队头是个占位符）
if (t == null) {
if (compareAndSetHead(new Node()))
tail = head;
//队列不为空，插入到队尾
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
3.2.2.5. 阻塞，等待唤醒继续获取锁
- acquireQueued
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
//死循环直到获取锁成功
for (;;) {
//逻辑1.
//当前节点的前一个节点时头节点的时候（公平锁：即我的前面没有人等待获取锁），尝试获取锁
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
//获取锁成功后设置头节点为当前节点
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
//逻辑2.
//当前节点的前一个节点状态时SIGNAL（承诺唤醒当前节点）的时候，阻塞当前线程。
//什么时候唤醒？释放锁的时候
//唤醒之后干什么？继续死循环执行上面的逻辑1
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
//何时执行这段逻辑？发生异常导致获取锁失败的时候
if (failed)
cancelAcquire(node);
}
}
3.2.2.5.1. 判断是否需要阻塞
- shouldParkAfterFailedAcquire
//根据（前一个节点，当前节点）->是否阻塞当前线程
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
//前一个节点的状态时SIGNAL，即释放锁后承诺唤醒当前节点，那么返回true可以阻塞当前线程
if (ws == Node.SIGNAL)
return true;
//前一个节点状态>0，即CANCEL。
//那么往前遍历找到没有取消的前置节点。同时从链表中移除CANCEL状态的节点
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
// 前置节点状态>=0，即0或者propagate。
//这里通过CAS把前置节点状态改成signal成功获取锁，失败的话再阻塞。why？
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
3.2.2.5.1.1. 阻塞当前线程
- parkAndCheckInterrupt
private final boolean parkAndCheckInterrupt() {
//使用Unsafe阻塞当前线程，这里会清除线程中断的标记，因此需要返回中断的标记
LockSupport.park(this);
return Thread.interrupted();
}
3.2.3. 解锁
public void unlock() {
//调用AQS的release方法
sync.release(1);
}
3.2.3.1. 使用AQS释放锁
- release
public final boolean release(int arg) {
//Sync重写了调用Sync释放锁成功
if (tryRelease(arg)) {
Node h = head;
//队头不为空且状态正常，那么唤醒头节点
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
Sync重写了tryRelease方法，因此这里调用的是Sync.tryRelease
其他的逻辑同5.AQS.md，下面只是简要说一下主要逻辑
3.2.3.2. 尝试释放锁
- Sync.tryRelease
protected final boolean tryRelease(int releases) {
//解锁
int c = getState() - releases;
//加锁解锁必须同一个线程
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
//锁全部释放成功后，置占用锁的线程为空
free = true;
setExclusiveOwnerThread(null);
}
//CAS设置解锁
setState(c);
return free;
}
3.2.3.3. 释放锁成功后唤醒阻塞队列中的节点
- AQS.unparkSuccessor
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
//当前节点的状态<0,则把状态改为0
//0是空的状态，因为node这个节点的线程释放了锁后续不需要做任何
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
//当前节点的下一个节点为空或者状态>0（即是取消状态）
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
//那么从队尾开始往前遍历找到离当前节点最近的下一个状态<=0的节点（即非取消状态）
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
//唤醒下一个节点（公平锁）
if (s != null)
LockSupport.unpark(s.thread);
}
4. 非公平锁
所谓非公平锁，就是只要锁已经被释放了，那么不管是先到的还是后到的，都可以去抢占锁
4.1. 如何使用
public class TestReentrantLock
{
private static int val = 0;
private final static Lock lock = new ReentrantLock();//非公平锁
public static void main(String[] args) throws InterruptedException
{
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 100000; i++)
{
try
{
lock.lock();
val++;
}
finally
{
lock.unlock();
}
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 100000; i++)
{
try
{
lock.lock();
val--;
}
finally
{
lock.unlock();
}
}
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println(val);
}
}
4.2. 实现原理
4.2.1. 构造方法
public class ReentrantLock implements Lock, java.io.Serializable {
private final Sync sync;
//默认非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
//true的话，公平锁使用FairSync，否则是NonfairSync
sync = fair ? new FairSync() : new NonfairSync();
}
//Sync是AQS的子类
abstract static class Sync extends AbstractQueuedSynchronizer {}
//FairSync是Sync的子类
static final class FairSync extends Sync {}
}
4.2.2. 加锁
public void lock() {
//简单得调用Sync属性的lock方法。即NonfairSync的lock方法
sync.lock();
}
4.2.2.1. 使用非公平锁加锁
- NonfairSync lock方法
final void lock() {
//获取锁。使用CAS设置state的值为1,这里state代表互斥量
if (compareAndSetState(0, 1))
//设置当前线程为拥有互斥量的线程
setExclusiveOwnerThread(Thread.currentThread());
else
//获取失败则调用AQS的acquire方法
acquire(1);
}
4.2.2.2. 通过AQS加锁
- AQS.acquire方法
public final void acquire(int arg) {
//调用NonFairSync的tryAcquire获取锁
if (!tryAcquire(arg) &&
//获取锁失败加入AQS队列。并且死循环阻塞当前线程，等待唤醒继续获取锁
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
//恢复中断标记
selfInterrupt();
}
由于NonfairSync重写了AQS的tryAcquire方法，因此这里会调用NonfairSync的tryAcquire
其他的逻辑同5.AQS.md，下面只是简要说一下主要逻辑
4.2.2.3. 通过非公平锁尝试加锁
- NonfairSync.tryAcquire
protected final boolean tryAcquire(int acquires) {
//调用NonfairSync.nonfairTryAcquire
return nonfairTryAcquire(acquires);
}
4.2.2.3.1. 非公平锁尝试加锁的操作【不管是否队头都可以抢占锁--非公平锁】
- NonfairSync.nonfairTryAcquire
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
//锁尚未被获取
if (c == 0) {
//不管前面是否有人等待，直接尝试获取锁（非公平锁）
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//锁已被获取且时当前线程，重入
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
4.2.2.4. 尝试加锁失败，加入阻塞队列
- AQS.addWaiter
private Node addWaiter(Node mode) {
//用当前线程、EXCLUSIVE模式构造节点
Node node = new Node(Thread.currentThread(), mode);
// 队列不为空
Node pred = tail;
if (pred != null) {
//插入到队尾
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//队列为空或者插入到队尾失败
enq(node);
return node;
}
4.2.2.4.1. 加入队列的操作
- AQS.enq
private Node enq(final Node node) {
//死循环直到入队成功
for (;;) {
Node t = tail;
//队列为空，那么初始化头节点。注意是new Node而不是当前node（即队头是个占位符）
if (t == null) {
if (compareAndSetHead(new Node()))
tail = head;
//队列不为空，插入到队尾
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
- acquireQueued
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
//死循环直到获取锁成功
for (;;) {
//逻辑1.
//当前节点的前一个节点时头节点的时候（公平锁：即我的前面没有人等待获取锁），尝试获取锁
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
//获取锁成功后设置头节点为当前节点
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
//逻辑2.
//当前节点的前一个节点状态时SIGNAL（承诺唤醒当前节点）的时候，阻塞当前线程。
//什么时候唤醒？释放锁的时候
//唤醒之后干什么？继续死循环执行上面的逻辑1
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
//如果发生了异常，那么执行下面的逻辑
} finally {
//除了获取锁成功的情况都会执行cancelAcquire方法
if (failed)
cancelAcquire(node);
}
}
- shouldParkAfterFailedAcquire
//根据（前一个节点，当前节点）->是否阻塞当前线程
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
//前一个节点的状态时SIGNAL，即释放锁后承诺唤醒当前节点，那么返回true可以阻塞当前线程
if (ws == Node.SIGNAL)
return true;
//前一个节点状态>0，即CANCEL。
//那么往前遍历找到没有取消的前置节点。同时从链表中移除CANCEL状态的节点
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
// 前置节点状态>=0，即0或者propagate。
//这里通过CAS把前置节点状态改成signal成功获取锁，失败的话再阻塞。why？
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
- parkAndCheckInterrupt
private final boolean parkAndCheckInterrupt() {
//使用Unsafe阻塞当前线程，这里会清除线程中断的标记，因此需要返回中断的标记
LockSupport.park(this);
return Thread.interrupted();
}
4.2.3. 解锁
public void unlock() {
//简单得调用AQS的release方法
sync.release(1);
}
4.2.3.1. 使用AQS释放锁
- release
public final boolean release(int arg) {
//调用Sync释放锁成功
if (tryRelease(arg)) {
Node h = head;
//队头不为空且状态正常，那么唤醒头节点
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
4.2.3.2. 尝试释放锁
- Sync.tryRelease
protected final boolean tryRelease(int releases) {
//解锁
int c = getState() - releases;
//加锁解锁必须同一个线程
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
//CAS设置解锁
setState(c);
return free;
}
4.2.3.2.1. 释放锁成功后唤醒阻塞队列中的后续节点
- unparkSuccessor
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
//当前节点的状态<0,则把状态改为0
//0是空的状态，因为node这个节点的线程释放了锁后续不需要做任何
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
//当前节点的下一个节点为空或者状态>0（即是取消状态）
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
//那么从队尾开始往前遍历找到离当前节点最近的下一个状态<=0的节点（即非取消状态）
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
//唤醒下一个节点（非公平锁也这样？）
if (s != null)
LockSupport.unpark(s.thread);
}
5. 参考
Java源码分析系列笔记-6.ReentrantLock的更多相关文章
- Java源码分析系列之HttpServletRequest源码分析
从源码当中 我们可以 得知,HttpServletRequest其实 实际上 并 不是一个类,它只是一个标准,一个 接口而已,它的 父类是ServletRequest. 认证方式 public int ...
- Java源码分析系列
1) 深入Java集合学习系列:HashMap的实现原理 2) 深入Java集合学习系列:LinkedHashMap的实现原理 3) 深入Java集合学习系列:HashSet的实现原理 4) 深入Ja ...
- MyCat源码分析系列之——结果合并
更多MyCat源码分析,请戳MyCat源码分析系列 结果合并 在SQL下发流程和前后端验证流程中介绍过,通过用户验证的后端连接绑定的NIOHandler是MySQLConnectionHandler实 ...
- MyCat源码分析系列之——SQL下发
更多MyCat源码分析,请戳MyCat源码分析系列 SQL下发 SQL下发指的是MyCat将解析并改造完成的SQL语句依次发送至相应的MySQL节点(datanode)的过程,该执行过程由NonBlo ...
- MyCat源码分析系列之——BufferPool与缓存机制
更多MyCat源码分析,请戳MyCat源码分析系列 BufferPool MyCat的缓冲区采用的是java.nio.ByteBuffer,由BufferPool类统一管理,相关的设置在SystemC ...
- [Tomcat 源码分析系列] (二) : Tomcat 启动脚本-catalina.bat
概述 Tomcat 的三个最重要的启动脚本: startup.bat catalina.bat setclasspath.bat 上一篇咱们分析了 startup.bat 脚本 这一篇咱们来分析 ca ...
- MyBatis 源码分析系列文章导读
1.本文速览 本篇文章是我为接下来的 MyBatis 源码分析系列文章写的一个导读文章.本篇文章从 MyBatis 是什么(what),为什么要使用(why),以及如何使用(how)等三个角度进行了说 ...
- spring源码分析系列 (8) FactoryBean工厂类机制
更多文章点击--spring源码分析系列 1.FactoryBean设计目的以及使用 2.FactoryBean工厂类机制运行机制分析 1.FactoryBean设计目的以及使用 FactoryBea ...
- spring源码分析系列 (5) spring BeanFactoryPostProcessor拓展类PropertyPlaceholderConfigurer、PropertySourcesPlaceholderConfigurer解析
更多文章点击--spring源码分析系列 主要分析内容: 1.拓展类简述: 拓展类使用demo和自定义替换符号 2.继承图UML解析和源码分析 (源码基于spring 5.1.3.RELEASE分析) ...
- spring源码分析系列 (1) spring拓展接口BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
更多文章点击--spring源码分析系列 主要分析内容: 一.BeanFactoryPostProcessor.BeanDefinitionRegistryPostProcessor简述与demo示例 ...
随机推荐
- llamacpp转换hf、vllm运行gguf
Linux通过huggingface安装大模型 huggingface官网 https://huggingface.co/ wget https://repo.anaconda.com/minicon ...
- DateTime.ToString(String) 格式化方法
小故事: 群里有位问了个问题:"dateime.now 怎么取20170610 这样格式的数据啊?"...然后等了好久,没人帮忙回答下(这里肯定少不了歧视和异议). 虽然问题很简单 ...
- pg的计算百分数的问题
SELECT cast("dept_id" as varchar(32)) , cast("dept_name" as varchar(30)) AS &quo ...
- PG的子查询：insert 没有就插入记录，update有则更新记录
insert into t --进行插入 values(1,'name') ON CONFLICT(id) --如果id这个键存在 do update set --更新以下字段 name=EXCLUD ...
- AXUI - 极致原生体验的零依赖的国产 Web UI 框架，欢迎体验和共建！
AXUI:专注于快速交付的国产 Web UI 框架 在日常的前端开发中,是否遇到过以下场景: 灵感乍现,希望快速通过一点代码实现原型或功能展示: 完全个人项目,开发方式自由,追求高效与便捷: 项目目标 ...
- 倍增 & Tarjan 求解LCA
什么是LCA? 假设我们有一棵树: 1 / \ 2 3 / \ / 4 5 6 对于 \(2\) 和 \(6\) 的LCA,就是最近公共祖先,即为距离 \(2\) 和 \(6\) 最近的两个节点公有的 ...
- 如何在 Linux 上检查开放的端口并关闭不需要的端口
检查服务器开放端口并关闭不必要的端口是网络安全管理中的关键环节,开放端口如同服务器的"窗口",若其中存在未被利用或未受保护的端口,就如同为潜在的攻击者敞开了大门,他们可能会利用这些 ...
- 谈谈笔者是怎么拿到HFish社区活动仅有的500京东E卡
前言 早在2022年5月18日的时候,由于HFish官方文档的nginx配置文件问题,官方文档的nginx配置存在多处错误.在HFish的社区群里为群友解答如何使用nginx进行反向代理以及提供能供正 ...
- 应用间通信(一)：详解Linux进程IPC
进程之间是独立的.隔离的,使得应用程序之间绝对不可以互相"侵犯"各自的领地. 但,应用程序之间有时是需要互相通信,相互写作,才能完成相关的功能,这就不得不由操作系统介入,实现一种通 ...
- POWERBI_创建工作区应用_协同办公能力 up up up
在powerbi中,我们往往会创建很多不同模型的报表,他们分别独立,但是在业务决策过程中,我们需要跨报表查看数据,反复切换报表,低效且忙乱 这个时候,合并展示报表是至关重要的 今天就一起学习一下,如何 ...