java架构之路(多线程)AQS之ReetrantLock显示锁的使用和底层源码解读

简介:

java架构之路(多线程)AQS之ReetrantLock显示锁的使用和底层源码解读

说完了我们的synchronized,这次我们来说说我们的显示锁ReetrantLock。

上期回顾:

上次博客我们主要说了锁的分类,synchronized的使用,和synchronized隐式锁的膨胀升级过程,从无锁是如何一步步升级到我们的重量级锁的,还有我们的逃逸分析。

锁的粗化和锁的消除

  这个本来应该是在synchronized里面去说的,忘记了,不是很重要,但是需要知道有这么一个东西啦。

我们先来演示一下锁的粗化:

StringBuffer sb = new StringBuffer();

public void lockCoarseningMethod(){

//jvm的优化,锁的粗化
sb.append("1");

sb.append("2");

sb.append("3");

sb.append("4");
AI 代码解读

}

我们都知道我们的StringBuffer是线程安全的,也就是说我们的StringBuffer是用synchronized修饰过的。那么我们可以得出我们的4次append都应该是套在一个synchronized里面的。

StringBuffer sb = new StringBuffer();

public void lockCoarseningMethod() {

synchronized (Test.class) {
    sb.append("1");
}

synchronized (Test.class) {
    sb.append("2");
}
synchronized (Test.class) {
    sb.append("3");
}
synchronized (Test.class) {
    sb.append("4");
}
AI 代码解读

}

按照理论来说应该是这样的,其实JVM对synchronized做了优化处理,底层会优化成一次的synchronized修饰,感兴趣的可以用javap -c 自己看一下,这里就不带大家去看了,我以前的博客有javap看汇编指令码的过程。

StringBuffer sb = new StringBuffer();

public void lockCoarseningMethod() {

synchronized (Test.class) {
    sb.append("1");
    sb.append("2");
    sb.append("3");
    sb.append("4");
}
AI 代码解读

}

再来看一下锁的消除,其实这个锁的消除,真的对于synchronized理解了,锁的消除一眼就知道是什么了。

public static void main(String[] args) {

synchronized (new Object()){
    System.out.println("开始处理逻辑");
}
AI 代码解读

}
对于synchronized而言,我们每次去锁的都是对象,而你每次都创建的一个新对象,那还锁毛线了,每个线程都可以拿到对象,都可以拿到对象锁啊,所以没不会产生锁的效果了。

概述AQS:

AQS是AbstractQueuedSynchronizer的简称,字面意思,抽象队列同步器。Java并发编程核心在于java.concurrent.util包而juc当中的大多数同步器 实现都是围绕着共同的基础行为,比如等待队列、条件队列、独占获取、共享获 取等,而这个行为的抽象就是基于AbstractQueuedSynchronizer简称AQS,AQS定 义了一套多线程访问共享资源的同步器框架,是一个依赖状态(state)的同步器。就是我们上次博客说的什么公平锁,独占锁等等。

AQS具备特性
阻塞等待队列
共享/独占
公平/非公平
可重入
允许中断
AQS的简单原理解读:

ReetrantLock的内部功能还是很强大的,有很多的功能,我们来一点点缕缕。如Lock,Latch,Barrier等,都是基于AQS框架实现,一般通过定义内部类Sync继承AQS将同步器所有调用都映射到Sync对应的方法AQS内部维护属性volatile int state (32位),state表示资源的可用状态

State三种访问方式
getState()
setState()
compareAndSetState()
AQS定义两种资源共享方式
Exclusive-独占,只有一个线程能执行,如ReentrantLock
Share-共享,多个线程可以同时执行,如Semaphore/CountDownLatch
AQS定义两种队列
同步等待队列
条件等待队列
AQS已经在顶层实现好了。自定义同步器实现时主要实现以下几种方法:
isHeldExclusively():该线程是否正在独占资源。只有用到condition才需要去实现它。
tryAcquire(int):独占方式。尝试获取资源,成功则返回true,失败则返回false。
tryRelease(int):独占方式。尝试释放资源,成功则返回true,失败则返回false。
tryAcquireShared(int):共享方式。尝试获取资源。负数表示失败;0表示成功,但没有剩余可用资源;正数表示成功,且有剩余资源。
tryReleaseShared(int):共享方式。尝试释放资源,如果释放后允许唤醒后续等待结点返回true,否则返回false。
刚才提到那么多属性,可能会有一些懵,我们来看一下ReentrantLock内部是怎么来实现哪些锁的吧。

打开我们的ReetrantLock源代码可以看到一个关键的属性

private final Sync sync;
后面有一个抽象方法并且继承了AbstractQueuedSynchronizer类,内部有一个用volatile修饰过的整型变量state,他就是用来记录上锁次数的,这样就实现了我们刚才的说的重入锁和非可重入锁。我们来画一个图。

AbstractQueuedSynchronizer这个类里面定义了详细的ReetrantLock的属性,后面我会一点点去说,带着解读一下源码(上面都是摘自源码的)。state和线程exclusiveOwnerThread比较好理解,最后那个队列可能不太好弄,我这里写的也是比较泛化的,后面我会弄一个专题一个个去说。 相面说的CLH队列其实不是很准确,我们可以理解为就是一个泛型为Node的双向链表结构就可以了。

等待队列中Node节点内还有三个很重要的属性就是prev前驱指针指向我们的前一个Node节点,和一个next后继指针来指向我们的下一个Node节点,这样就形成了一个双向链表的结构,于此同时还有一个Thread来记录我们的当前线程。

在条件队列中,prev和next指针都是null的,不管是什么队列,他都有一个waitStatus的属性来记录我们的节点状态的,就是我们刚才说的CANCELLED结束、SIGNAL可唤醒那四个常量值。

AQS中ReetrantLock的使用:

公平锁和非公平锁:这个还是比较好记忆的,举一个栗子,我们去车站排队上车,总有**插队,用蛇形走位可以上车的是吧,这就是一个非公平的锁,如果说,我们在排队的时候加上护栏,每次只能排一个人,他人无法插队的,这时就是一个公平锁。总之就是不加塞的就是公平的,我们都讨厌不公平。

重入锁与非可重入锁:这个也很好理解,重入锁就是当我们的线程A拿到锁以后,可以继续去拿多把锁,然后再陆陆续续的做完任务再去解锁,非可重入呢,就是只能获得一把锁,如果想获取多把锁,不好意思,去后面排下队伍。下面我化了一个重入锁的栗子,快过年了,大家提着行李回老家,我们进去了会一并带着行李进去(不带行李的基本是行李丢了),这就是一个重入锁的栗子,我们人进去了获得通道通过(锁),然后我们也拖着行李获得了通道通过(锁),然后我们才空出通道供后面的人使用。如果是非可重入锁就是人进去就进去吧,行李再次排队,说不准什么时候能进来。

上一段代码来验证一下我们上面说的那些知识点。

import java.util.concurrent.locks.ReentrantLock;

public class Test {

private ReentrantLock lock = new ReentrantLock(true);//true公平锁,false非公平锁
AI 代码解读
public void lockMethod(String threadName) {
    lock.lock();
    System.out.println(threadName + "得到了一把锁1");

    lock.lock();
    System.out.println(threadName + "得到了一把锁2");

    lock.lock();
    System.out.println(threadName + "得到了一把锁3");

    lock.unlock();
    System.out.println(threadName + "释放了一把锁1");

    lock.unlock();
    System.out.println(threadName + "释放了一把锁2");

    lock.unlock();
    System.out.println(threadName + "释放了一把锁3");
}
AI 代码解读
public static void main(String[] args) {
    Test test = new Test();

    new Thread(() -> {
        String threadName = Thread.currentThread().getName();
        test.lockMethod(threadName);

    }, "线程A").start();
}
AI 代码解读

}

通过代码阅读我们知道我们弄一个重入锁,加三次锁,解三次锁,我们来看一下内部sync的变化,调试一下。

我们看到了我们的state变量是用来存储我们的入锁次数的。刚才去看过源码的小伙伴知道了我们的state是通过volatile修饰过的,虽然可以保证我们的有序性和可见性,但是一个int++的操作,他是无法保证原子性的,我们继续来深挖一下代码看看内部是怎么实现高并发场景下保证数据准确的。点击lock方法进去,我们看到lock方法是基于sync来操作的,就是我们上面的画的那个ReetrantLock的图。

/**

  • Sync object for fair locks
    */

static final class FairSync extends Sync {

private static final long serialVersionUID = -3000897897090466540L;

final void lock() {//开始加锁
    acquire(1);
}

/**
 * Fair version of tryAcquire.  Don't grant access unless
 * recursive call or no waiters or is first.
 */
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();//得到当前线程
    int c = getState();//得到上锁次数
    if (c == 0) {//判断是否上过锁
        if (!hasQueuedPredecessors() &&//hasQueuedPredecessors判断是否有正在等待的节点,
                compareAndSetState(0, acquires)) {//通过unsafe去更新上锁次数
            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;
}
AI 代码解读

}

这次我们开启多个线程来同时访问来看一下我们的Node的变化。同时开启ABCD四个线程来执行这个

这次我们看到了head属性和tail属性不再是空的。head是也是一个node节点,前驱指针是空的,后驱指针指向后继节点,Thread为空,tail的node节点正好是和head相对应的节点。这样的设计就是为了更好的去验证队列中还是否存在剩余的线程节点需要处理。然后该线程运行结束以后会唤醒在队列中的节点,然其它线程继续运行。

我们知道我们创建的公平锁,如果说BCD好好的在排队,E线程来了,只能好好的去排队,因为公平,所以排队,如果我们创建的是非公平锁,E线程就有机会拿到锁,拿到就运行,拿不到就去排队。

原文地址https://www.cnblogs.com/cxiaocai/p/12191666.html

相关文章
智慧产科一体化管理平台源码,基于Java,Vue,ElementUI技术开发,二开快捷
智慧产科一体化管理平台覆盖从备孕到产后42天的全流程管理,构建科室协同、医患沟通及智能设备互联平台。通过移动端扫码建卡、自助报道、智能采集数据等手段优化就诊流程,提升孕妇就诊体验,并实现高危孕产妇五色管理和孕妇学校三位一体化管理,全面提升妇幼健康宣教质量。
40 12
Java智慧工地(源码):数字化管理提升施工安全与质量
随着科技的发展,智慧工地已成为建筑行业转型升级的重要手段。依托智能感知设备和云物互联技术,智慧工地为工程管理带来了革命性的变革,实现了项目管理的简单化、远程化和智能化。
34 4
基于Java+SpringBoot+Vue实现的车辆充电桩系统设计与实现(系统源码+文档+部署讲解等)
面向大学生毕业选题、开题、任务书、程序设计开发、论文辅导提供一站式服务。主要服务:程序设计开发、代码修改、成品部署、支持定制、论文辅导,助力毕设!
61 6
建筑施工一体化信息管理平台源码,支持微服务架构,采用Java、Spring Cloud、Vue等技术开发。
智慧工地云平台是专为建筑施工领域打造的一体化信息管理平台,利用大数据、云计算、物联网等技术,实现施工区域各系统数据汇总与可视化管理。平台涵盖人员、设备、物料、环境等关键因素的实时监控与数据分析,提供远程指挥、决策支持等功能,提升工作效率,促进产业信息化发展。系统由PC端、APP移动端及项目、监管、数据屏三大平台组成,支持微服务架构,采用Java、Spring Cloud、Vue等技术开发。
基于 SpringBoot 和 Vue 开发校园点餐订餐外卖跑腿Java源码
一个非常实用的校园外卖系统,基于 SpringBoot 和 Vue 的开发。这一系统源于黑马的外卖案例项目 经过站长的进一步改进和优化,提供了更丰富的功能和更高的可用性。 这个项目的架构设计非常有趣。虽然它采用了SpringBoot和Vue的组合,但并不是一个完全分离的项目。 前端视图通过JS的方式引入了Vue和Element UI,既能利用Vue的快速开发优势,
158 13
后端服务架构的微服务化转型
本文旨在探讨后端服务从单体架构向微服务架构转型的过程,分析微服务架构的优势和面临的挑战。文章首先介绍单体架构的局限性,然后详细阐述微服务架构的核心概念及其在现代软件开发中的应用。通过对比两种架构,指出微服务化转型的必要性和实施策略。最后,讨论了微服务架构实施过程中可能遇到的问题及解决方案。
云计算的未来:云原生架构与微服务的革命####
【10月更文挑战第21天】 随着企业数字化转型的加速,云原生技术正迅速成为IT行业的新宠。本文深入探讨了云原生架构的核心理念、关键技术如容器化和微服务的优势,以及如何通过这些技术实现高效、灵活且可扩展的现代应用开发。我们将揭示云原生如何重塑软件开发流程,提升业务敏捷性,并探索其对企业IT架构的深远影响。 ####
84 3
云原生架构下的微服务治理与挑战####
随着云计算技术的飞速发展,云原生架构以其高效、灵活、可扩展的特性成为现代企业IT架构的首选。本文聚焦于云原生环境下的微服务治理问题,探讨其在促进业务敏捷性的同时所面临的挑战及应对策略。通过分析微服务拆分、服务间通信、故障隔离与恢复等关键环节,本文旨在为读者提供一个关于如何在云原生环境中有效实施微服务治理的全面视角,助力企业在数字化转型的道路上稳健前行。 ####
从单体到微服务:如何借助 Spring Cloud 实现架构转型
**Spring Cloud** 是一套基于 Spring 框架的**微服务架构解决方案**,它提供了一系列的工具和组件,帮助开发者快速构建分布式系统,尤其是微服务架构。
311 69
从单体到微服务:如何借助 Spring Cloud 实现架构转型
智慧工地云平台的技术架构解析:微服务+Spring Cloud如何支撑海量数据?
慧工地解决方案依托AI、物联网和BIM技术,实现对施工现场的全方位、立体化管理。通过规范施工、减少安全隐患、节省人力、降低运营成本,提升工地管理的安全性、效率和精益度。该方案适用于大型建筑、基础设施、房地产开发等场景,具备微服务架构、大数据与AI分析、物联网设备联网、多端协同等创新点,推动建筑行业向数字化、智能化转型。未来将融合5G、区块链等技术,助力智慧城市建设。
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等