并发编程（五）：AQS之重入锁ReentrantLock

最新推荐文章于 2024-08-19 21:26:48 发布
最新推荐文章于 2024-08-19 21:26:48 发布
阅读量175 收藏
点赞数
分类专栏： 并发编程 文章标签： 并发编程 AQS 重入锁 ReentrantLock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011976388/article/details/102238964
版权

一，AQS源码博文：并发编程：AbstractQueuedSynchronizer源码分析

二，ReentrantLock重入锁基本介绍

    1，类图

        * 从图中可以看到，ReentrantLock是顶层锁接口Lock的实现类，并实现了Lock所定义的关于锁操作的基本API

        * ReentrantLock内部定义了三个有继承关系的内部类，Sync，FairSync，NonfairSync

        * 其中Sync继承自AQS类，是ReentrantLock底层通过AQS进行线程调度的基础和扩展

        * FairSync和NonfairSync分别继承自Sync类，是ReentrantLock对于公平锁和非公平锁的不同实现

    2，重入锁

        a，重入锁，表示重新进入的锁。也就是如果线程1通过调用lock方法获取了锁之后，再次调用lock，是不会阻塞等待获取锁的（如果等待，直接死锁），只需要增加锁的重入次数（即state）就可以（getHoldCount()）。同时，在释放锁时，也不是直接释放掉当前线程的锁，而是对重入次数（即state）递减。当state为0时，再进行锁释放并唤醒下一个队列节点！如下例子

package com.gupao.concurrent;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 独占锁演示
 * @author pj_zhang
 * @create 2019-10-01 14:28
 **/
public class ExclusiveTest {

    // 定义全局重入锁对象
    private static final ReentrantLock reentrantLock = new ReentrantLock();

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            // 遍历并启动100道线程
            Thread thread = new Thread(() -> {
                try {
                    // 线程内部加锁并沉睡业务秒数，模拟获取到锁后不立即释放
                    // 多次加锁，模拟重入锁
                    reentrantLock.lock();
                    reentrantLock.lock();
                    reentrantLock.lock();
                    Thread.sleep(3000);
                    System.out.println(
                            Thread.currentThread().getName() + "获取锁，执行时间: "
                                    + System.currentTimeMillis());
                    // 通过getHoldCount()获取重入次数
                    System.out.println("当前重入次数：" + reentrantLock.getHoldCount());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // finally块中释放锁
                    // 此处只释放一次，模拟线程依旧阻塞，则不会唤醒阻塞线程，整个流程在此阻塞
                    reentrantLock.unlock();
                    System.out.println("释放一次后重入次数：" + reentrantLock.getHoldCount());
                }
            }, "THREAD_" + i);
            thread.start();
            System.out.println(thread.getName() + "启动成功...");
        }
    }
}

    3，常用API

        * 构造器

// 默认初始化非公平锁
public ReentrantLock() {
	sync = new NonfairSync();
}
// 通过参数指定，构造公平锁或者非公平锁
public ReentrantLock(boolean fair) {
	sync = fair ? new FairSync() : new NonfairSync();
}

        * 常用方法

// 加锁
void lock();
// 加锁，中断后抛异常
void lockInterruptibly() throws InterruptedException;
// 尝试加锁
boolean tryLock();
// 尝试加锁_带时间
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
// 解锁
void unlock();
// 获取重入次数
int getHoldCount();
...

三，非公平锁源码解析

    1，构造器

// 默认构造器
public ReentrantLock() {
	sync = new NonfairSync();
}
// 获取有参构造传递false
public ReentrantLock(boolean fair) {
	sync = fair ? new FairSync() : new NonfairSync();
}

    2，尝试加锁源码解析

        2.1，尝试加锁_不带时间

            * tryLock()：尝试加锁

public boolean tryLock() {
	// 调用Sync的方法，即父类方法，此处公平锁和非公平锁一致
	return sync.nonfairTryAcquire(1);
}

            * java.util.concurrent.locks.ReentrantLock.Sync#nonfairTryAcquire(int acquires)

final boolean nonfairTryAcquire(int acquires) {
	// 获取当前线程
	final Thread current = Thread.currentThread();
	// 获取state，即重入次数
	int c = getState();
	if (c == 0) {
		// state为0，说明锁空闲，通过CAS替换加锁
		if (compareAndSetState(0, acquires)) {
			// 替换成功后，将当前线程设置为独占线程
			setExclusiveOwnerThread(current);
			return true;
		}
	}
	// 如果当前线程就是独占线程，表示重入
	else if (current == getExclusiveOwnerThread()) {
		// 重入次数加上acquires表示的次数
		int nextc = c + acquires;
		if (nextc < 0) // overflow
			throw new Error("Maximum lock count exceeded");
		// 并替换state的值
		setState(nextc);
		return true;
	}
	// 以上如果ruturn说明获取锁成功
	// 否则失败
	return false;
}

         2.2，尝试加锁_带时间

            * tryLock(long timeout, TimeUnit unit)：尝试带时间加锁

public boolean tryLock(long timeout, TimeUnit unit)
		throws InterruptedException {
	// 此处调用AQS.tryAcquireNanos尝试加锁，注意将时间转换为纳秒
	return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

            * AQS.tryAcquireNanos() 已经在AQS博文中解析，继续跟踪代码，会发现 tryAcquire() 方法在子类中重新定义，此处只对 tryAcquire() 方法进行分析

            * java.util.concurrent.locks.ReentrantLock.NonfairSync#tryAcquire(int acquires)：可以发现 tryAcquire() 中依旧调用 nonfairTryAcquire() 方法尝试获取锁

protected final boolean tryAcquire(int acquires) {
	return nonfairTryAcquire(acquires);
}

    3，加锁源码解析

        * lock()：加锁

public void lock() {
	// 此处调用非公平锁的 lock() 方法
	sync.lock();
}

        * java.util.concurrent.locks.ReentrantLock.NonfairSync#lock()：调用非公平锁的 lock() 方法

final void lock() {
	// 替换 state 状态，为0表示没有线程加锁，成功替换为1说明当前线程加锁成功
	if (compareAndSetState(0, 1))
		// 将独占线程指向当前线程
		setExclusiveOwnerThread(Thread.currentThread());
	else
		// 调用AQS的 acquire() 方法进行加锁，参考AQS源码博文
		// 加锁失败后会添加到AQS同步队列
		acquire(1);
}

    4，释放锁源码解析

        * unlock()

public void unlock() {
	// 调用AQS.release方法
	sync.release(1);
}

        * java.util.concurrent.locks.AbstractQueuedSynchronizer#release(int arg)：AQS中释放锁，先通过业务代码尝试释放锁，释放成功后唤醒下一个节点

public final boolean release(int arg) {
	// 调用Sync.tryRelease尝试释放锁
	if (tryRelease(arg)) {
		// 释放锁成功后，唤醒同步队列上的下一个节点
		Node h = head;
		if (h != null && h.waitStatus != 0)
			unparkSuccessor(h);
		return true;
	}
	return false;
}

        * java.util.concurrent.locks.ReentrantLock.Sync#tryRelease(int releases)：重入锁自定义尝试释放逻辑

protected final boolean tryRelease(int releases) {
	// 对state进行递减，获取递减后的state值
	int c = getState() - releases;
	if (Thread.currentThread() != getExclusiveOwnerThread())
		throw new IllegalMonitorStateException();
	boolean free = false;
	// 如果c为0，表示所有重入已经被全部释放
	if (c == 0) {
		free = true;
		// 将独占线程为空，当前线程不在占有锁
		setExclusiveOwnerThread(null);
	}
	// 对state赋递减后的值
	setState(c);
	return free;
}

四，公平锁源码解析

    1，构造器

// 获取有参构造传递true
public ReentrantLock(boolean fair) {
	sync = fair ? new FairSync() : new NonfairSync();
}

    2，尝试加锁源码解析

        2.1，尝试加锁_不带时间

            * 与公平锁一致，此处翻代码没有非公平锁实现，疑惑ING！！！

public boolean tryLock() {
     return sync.nonfairTryAcquire(1);
}

        2.2，尝试加锁_带时间

             * 之前步骤与公平锁一致，调用最终到 tryAcquire() 调用自定义方法

             * java.util.concurrent.locks.ReentrantLock.FairSync#tryAcquire(int acquires)：尝试获取锁，注意公平锁与非公平锁尝试获取锁的区别

protected final boolean tryAcquire(int acquires) {
	final Thread current = Thread.currentThread();
	// 获取当前状态
	int c = getState();
	if (c == 0) {
		// hasQueuedPredecessors：判断是否存在等待的前置节点，存在则获取失败
		// 这也是公平锁和非公平锁的最主要区别，默认排到队尾执行，非公平锁直接插队获取锁
		if (!hasQueuedPredecessors() &&
			compareAndSetState(0, acquires)) {
			setExclusiveOwnerThread(current);
			return true;
		}
	}
	// 占有线程为当前线程，锁重入
	else if (current == getExclusiveOwnerThread()) {
		int nextc = c + acquires;
		if (nextc < 0)
			throw new Error("Maximum lock count exceeded");
		setState(nextc);
		return true;
	}
	return false;
}

        * java.util.concurrent.locks.AbstractQueuedSynchronizer#hasQueuedPredecessors()：判断队列中是否存在等待元素

public final boolean hasQueuedPredecessors() {
	// 尾结点
	Node t = tail;
	// 头节点
	Node h = head;
	Node s;
	// 头节点不是尾结点，说明存在多个节点
	// 头节点的next为空，说明头节点正在运行中
	// 或者next节点线程和当前线程不一致，说明存在等待线程
	return h != t &&
		((s = h.next) == null || s.thread != Thread.currentThread());
}

    3，加锁源码解析

        * 公平锁的 lock() 与非公平锁的 lock() 相比，同样是在每次调用 tryAcquire() 时，调用不同的实现。不同的实现已经在上面解析

    4，释放锁源码解析

        * 公平锁与非公平锁一致

传说中的靖哥哥
关注
专栏目录
Java 并发编程：ReentrantLock 锁与 AQS
栗筝i的博客
08-10 1176
大家好，我是栗筝i，这篇文章是我的 “栗筝i 的 Java 技术栈” 专栏的第 030 篇文章，在 “栗筝i 的 Java 技术栈” 这个专栏中我会持续为大家更新 Java 技术相关全套技术栈内容。专栏的主要目标是已经有一定 Java 开发经验，并希望进一步完善自己对整个 Java 技术体系来充实自己的技术栈的同学。与此同时，本专栏的所有文章，也都会准备充足的代码示例和完善的知识点梳理，因此也十分适合零基础的小白和要准备工作面试的同学学习。
Java并发编程：用AQS写一把可重入锁
张翠山的博客
11-12 6347
测试类 /** * MyAqsLock的测试类 */ public class Main { private int value; private Lock lock = new MyAqsLock(); private Lock lock1 = new ReentrantLock(); public int increment() { ...
可重入锁总结
大鸡腿的博客
03-20 429
ReentrantLock与Synchronized都是可重入锁 具体什么是可重入锁？ 当一个线程获取这个锁之后，再次获取锁不会造成死锁，实现原理：每次获得锁之后，记录拥有锁的线程id以及获得锁的次数。再次获取的时候，如果这个锁不是它的则要等待，如果是它的话，总数+1。当释放的时候，拥有锁的个数减一。 作用：可重入锁是为了避免死锁。 public class Test implement...
关于重入锁的理解
热门推荐
千年祸害万年牢
10-11 1万+
package com.joker.test; import java.util.concurrent.locks.ReentrantLock; /**  *可重入锁  *所谓重入锁，指的是以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象上的锁，而其他的线程是不可以的  *synchronized 和   ReentrantLock 都是可重入锁  *可重入锁的意义在
Java限制可以重入次数的锁
weixin_33686714的博客
11-29 387
完全 模仿ReentrantLock， 通过继承 java.util.concurrent.locks.Lock , 内置 AbstractQueuedSynchronizer 实现类，限制可以重入次数的锁。 这个其实不难， 只要稍微注意一点就好了  ReenterLimitedLock  关键实现： /** * l.k * * 限制可以重入次数的锁，默认是2次 * ...
【并发编程】详解 ReentrantLock：深入剖析 AQS 支撑下的可重入锁机制与实现原理
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
08-19 2570
【并发编程】详解 ReentrantLock：深入剖析 AQS 支撑下的可重入锁机制与实现原理
并发编程之可重入锁ReentrantLock
勤于笔记，成于点滴。
04-25 887
今天的博文我们讲述了ReentrantLock与Synchronized的区别联系，也解析了ReentrantLock可重入、可中断、超时机制以及conditon变量的源码。通过源码我们可以知道ReentrantLock 是通过AQS保证同步，其他的中断机制、超时机制、以及condition变量也都是基于AQS中的相应底层代码。在实际的开发过程中，我们可以根据自身业务场景选择应用ReentrantLock方法，从而增加系统的健壮性和可维护性。
并发编程之深入理解六：AQS之独占锁ReentrantLock
Men-DD
03-04 103
AQS原理分析 什么是AQS java.util.concurrent包中的大多数同步器实现都是围绕着共同的基础行为，比如等待队 列、条件队列、独占获取、共享获取等，而这些行为的抽象就是基于 AbstractQueuedSynchronizer(简称AQS)实现的，AQS是一个抽象同步框架，可以用来实 现一个依赖状态的同步器。 JDK中提供的大多数的同步器如Lock, Latch, Barrier等，都是基于AQS框架来实现的 一般是通过一个内部类Sync继承 AQS 将同步器所有调用都映射到Sync对应
可重入锁ReentrantLock源码解读
小小本科生
01-24 939
ReentrantLock基于AQS，在并发编程中它可以实现公平锁和非公平锁来对共享资源进行同步。同时，和synchronized—样，ReentrantLock支持可重入。除此之外，ReentrantLock在调度上更灵活，支持更多丰富的功能。在Java SE 5 之后，并发包中新增了Lock接口用来实现锁功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需要显示地获取和释放锁。Lock的意义在于提供了区别于synchronized的另一种具有更多广泛操作的同步方式。
Java源码解析之可重入锁ReentrantLock
08-26
ReentrantLock是一个功能强大且灵活的可重入锁，它可以满足各种并发编程的需求。通过对ReentrantLock的源码分析，我们可以更好地理解ReentrantLock的实现机制和使用场景，从而更好地应用于实际开发中。 知识点： 1...
详解java并发之重入锁-ReentrantLock
08-26
详解 Java 并发之重入锁-ReentrantLock Java 中的并发编程是一种复杂的技术，需要深入了解 Java 的并发机制和锁机制。ReentrantLock 是 Java 中的一种常用锁机制，它提供了一个可重入的锁机制，能够确保线程安全。...
让-Flutter-在鸿蒙系统上跑起来，目录：鸿蒙系统适配；渲染流程打通；Flutter在鸿蒙系统上的移植
最新发布
09-29
鸿蒙----目录： 1、鸿蒙系统适配 2、渲染流程打通 3、Flutter在鸿蒙系统上的移植
【PFJSP问题】基于matlab灰狼算法GWO求解置换流水车间调度问题PFSP【含Matlab源码 7899期】.mp4
09-28
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
基于TypeScript和Vue的日历展示与日程条创建设计源码
09-28
该项目为基于TypeScript和Vue构建的日历展示与日程条创建设计源码，包含33个文件，涉及10个TypeScript文件、5个JSON文件、4个LESS样式文件、3个Vue组件文件、2个JavaScript和SVG文件，以及HTML、Git忽略和Markdown文档等。该系统具备日历查看和日程条创建功能，适用于个人或团队日程管理需求。
基于Java语言实现的XXL-JOB分布式定时任务设计源码注释
09-28
该项目为XXL-JOB分布式定时任务系统设计源码，采用Java语言开发，辅以JavaScript和CSS进行界面设计。项目文件总计288个，其中Java源文件133个，PNG图片文件35个，JavaScript文件35个，XML配置文件16个，CSS样式文件12个，FTL模板文件11个，属性文件6个，Markdown文件3个，JPG图片文件3个，EOT字体文件3个。源码注释详尽，旨在提升代码可读性和维护性。
基于Vue框架的邻家优选电商平台设计源码
09-28
该项目是一款采用Vue框架开发的邻家优选电商平台设计源码，包含共计48个文件，涵盖17个Vue组件文件、10个JavaScript脚本文件、8个JPG图片文件、4个JSON配置文件、4个PNG图片文件，以及必要的配置文件和图标文件。该系统由Ipang组设计，旨在提供一站式购物体验。
基于JavaScript的Express框架开发的前端HTML+CSS设计源码
09-28
该项目是一款采用JavaScript及Express框架构建的前端HTML与CSS设计源码集合，共包含228个文件，其中JavaScript文件152个，EJS模板文件20个，Markdown文件13个，文本文件10个，HTML文件8个，模板文件7个，CSS文件4个，YAML文件3个，Handlebars模板文件3个，配置文件1个。该源码集合适用于快速开发前端界面，支持现代Web设计标准。
深入理解Java并发：基于AQS构建可重入锁
"Java并发编程：使用AQS构建可重入锁" 在Java并发编程中，AbstractQueuedSynchronizer（AQS）扮演着至关重要的角色。AQS是Java并发库（java.util.concurrent，简称J.U.C）中的一个抽象类，提供了一种基于FIFO（先进...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值