JUC高级-0625

最新推荐文章于 2024-04-30 12:12:17 发布
最新推荐文章于 2024-04-30 12:12:17 发布
阅读量194 收藏
点赞数
分类专栏： JUC 文章标签： java juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lannister_awalys_pay/article/details/131388438
版权

13. AbstractQueuedSynchronized之AQS

13.1 前置知识

  1. 公平锁和非公平锁
  2. 可重入锁
  3. 自旋思想
  4. LockSupport
  5. 数据结构之双向链表
  6. 设计模式之模板设计模式

13.2 AQS入门级别理论知识

  1. AQS是什么？
    1. 字面意思：抽象的队列同步器，实现了通知唤醒的机制
    2. 源代码
      请添加图片描述
    3. 技术解释
      1. 是用来实现锁或者其它同步器组件的公共基础部分的抽象实现，是重量级基础框架及整个JUC体系的基石，主要用于解决锁分配给"谁"的问题
      2. 整体就是一个抽象的FIFO队列来完成资源获取线程的排队工作，并通过一个int类变量表示持有锁的状态
      3. 为实现阻塞锁和相关的同步器提供一个框架，它是依赖于先进先出的一个等待。依靠单个原子int值来表示状态，通过占用和释放方法，改变状态值
      4. 请添加图片描述
    4. AQS是JUC基石
      请添加图片描述
    5. 进一步理解锁和同步器的关系
      1. 锁，面向锁的使用者：定义了程序员和锁交互的使用层APl，隐藏了实现细节，你调用即可。
      2. 同步器，面向锁的实现者：Java并发大神DougLee，提出统一规范并简化了锁的实现，将其抽象出来屏蔽了同步状态管理、同步队列的管理和维护、阻塞线程排队和通知、唤醒机制等，是一切锁和同步组件实现的--------公共基础部分
    6. 能做什么？
      1. 加锁会导致阻塞：在阻塞就需要排队，实现排队必然需要队列
      2. 解释说明：
        1. 抢到资源的线程直接使用处理业务，抢不到资源的必然涉及一种排队等候机制。抢占资源失败的线程继续去等待(类似银行业务办理窗口都满了，暂时没有受理窗口的顾客只能去候客区排队等候)，但等候线程仍然保留获取锁的可能且获取锁流程仍在继续(候客区的顾客也在等着叫号，轮到了再去受理窗口办理业务)。
        2. 既然说到了排队等候机制，那么就一定会有某种队列形成，这样的队列是什么数据结构呢？
        3. 如果共享资源被占用，就需要一定的阻塞等待唤醒机制来保证锁分配。这个机制主要用的是CLH队列的变体实现的，将暂时获取不到锁的线程加入到队列中，这个队列就是AQS的抽象表现。它将请求共享资源的线程封装成队列的结点==（Node）==，通过CAS、自旋以及LockSupport.park()的方式，维护state变量的状态，使并发达到同步的效果。
        4. 总结：AQS使用一个volatile的int类型的成员变量来表示同步状态，通过内置的FIFO队列来完成资源获取的排队工作将每条要去抢占资源的线程封装成一个Node节点来实现锁的分配，通过CAS完成对State值的修改。
  2. 基本结构：
    请添加图片描述

13.3 AQS源码分析前置知识储备

  1. AQS本质：双向队列+state状态位，内部靠Node节点形成队列
  2. AQS内部体系架构
    请添加图片描述
  3. AQS自身：
    1. AQS的int变量volatile int state，也就是13.2.2图中的state
    2. AQS的CLH队列：也就是13.2.2图中的队列。三个科学家名字拼起来的。
    3. 属性：头尾指针外加state属性
      private transient volatile Node head;
private transient volatile Node tail;
private volatile int state;
    4. 小总结：
      1. 有阻塞就需要排队，实现排队必然需要队列
      2. state变量+CLH双端队列
  4. AQS内部类Node：
    //	共享
static final Node SHARED = new Node();
//	独占       
static final Node EXCLUSIVE = null;
// 线程被取消了        
static final int CANCELLED =  1;	
//	后继线程需要唤醒      
static final int SIGNAL    = -1;
//	等待condition唤醒        
static final int CONDITION = -2;
//	共享式同步状态获取将会无条件地传播下去       
static final int PROPAGATE = -3;
//	初始为0，状态是上面的几种
volatile int waitStatus;		//	很重要
//	前置节点
volatile Node prev;
//	后置节点
volatile Node next;

volatile Thread thread;
    等候区其它顾客(其它线程）的等待状态，队列中每个排队的个体就是一个 Node
  5. Node属性说明：
    请添加图片描述

13.4 AQS源码深度讲解和分析

此部分：AQS源码分析——以ReentrantLock为例

13.5 源码分析总结

请添加图片描述
请添加图片描述
请添加图片描述

14. ReentrantLock、 ReentrantReadWriteLock、 StampedLock讲解

  1. 本章主线：无锁——独占锁——读写锁——邮戳锁

14.1 简单聊聊ReentrantReadWriteLock

  1. 是什么
    1. 是ReadWriteLock的实现类
    2. 读写锁定义为：一个资源能够被多个國线程访间，或者被工个写线程访问，但是不能同时存在读写线程。
    3. 简单说，一锁多用；一体两面，读写互斥，读读共享
  2. 演变：无锁无序——加锁——读写锁演变
    1. 请添加图片描述
    2. 写线程饥饿问题
    3. 锁降级
  3. 读写锁意义和特点：
    1. 『读写锁ReentrantReadWriteLock』并不是真正意义上的读写分离，它只允许读读共存，而读写和写写依然是互斥的，大多实际场景是“读/读”线程间并不存在互斥关系，只有"读/写"线程或"写/写"线程间的操作需要互斥的。因此引入ReentrantReadWriteLock。
    2. 一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁，但不能同时存在写锁和读锁(切菜还是拍蒜选一个)。也即一个资源可以被多个读操作访问或一个写操作访问，但两者不能同时进行。
    3. 只有在读多写少情境之下，读写锁才具有较高的性能体现。
  4. 锁降级
    1. 锁降级：遵循获取写锁→再获取读锁→再释放写锁的次序，写锁能够降级成为读锁。如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁。
    2. Java8 官网说明：
      重入还允许通过获取写入锁定，然后读取锁然后释放写锁从写锁到读取锁, 但是，从读锁定升级到写锁是不可能的。
    3. 写锁的降级，降级成为了读锁
      1. 目的：锁降级是为了让当前线程感知到数据的变化，目的是保证数据可见性
      2. 如果同一个线程持有了写锁，在没有释放写锁的情况下，它还可以继续获得读锁。这就是写锁的降级，降级成为了读锁。
      3. 规则惯例，先获取写锁，然后获取读锁，再择放写锁的 次序。
      4. 如果释放了写锁，那么就完全转换为读锁。
      5. 请添加图片描述
    4. 锁降级特性：
      1. 公平性选择：支持非公平（默认）和公平的锁获取方式，吞吐量还是非公平优于公平
      2. 重进入：该锁支持重进人，以读写线程为例：读线程在获取了读锁之后，能够再次获取读锁。而写线程在获取了写锁之后能够再次获取写锁，同时也可以获取读锁
      3. 锁降级：遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级成为读锁
    5. 代码演示：见https://blog.csdn.net/lannister_awalys_pay/article/details/131078204 9.4
    6. 不可锁升级：
      请添加图片描述
    7. 小总结：
      1. 写锁和读锁是互斥的（这里的互斥是指线程间的互斥，当前线程可以获取到写锁又获取到读锁，但是获取到了读锁不能继续获取写锁），这是因为读写锁要保持写操作的可见性。因为，如果允许读锁在被获取的情况下对写锁的获取，那么正在运行的其他读线程无法感知到当前写线程的操作。
      2. 因此，分析读写锁ReentrantReadWriteLock，会发现它有个潜在的问题：读锁全完，写锁有望；写锁独占，读写全堵；如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁，见前面Case《code演示LockDownGradingDemo》即ReadWriteLock读的过程中不允许写，只有等待线程都释放了读锁，当前线程才能获取写锁，也就是写入必须等待，这是一种悲观的读锁，o(╥﹏╥)o，人家还在读着那，你先别去写，省的数据乱。
      3. =========后续讲解StampedLock时再详细展开===========
        分析StampedLock(后面详细讲解)，会发现它改进之处在于：读的过程中也允许获取写锁介入(相当牛B，读和写两个操作也让你“共享”(注意引号))，这样会导致我们读的数据就可能不一致！所以，需要额外的方法来判断读的过程中是否有写入，这是一种乐观的读锁，O(∩_∩)O哈哈~。 显然乐观锁的并发效率更高，但一旦有小概率的写入导致读取的数据不一致，需要能检测出来，再读一遍就行。
  5. 锁降级设计思想：
    1. 简单讲：希望写后可以立刻读，不希望被其他写线程抢占并修改。那么释放写锁之前先加读锁。
    2. 锁降级 下面的示例代码摘自ReentrantWriteReadLock源码中：ReentrantWriteReadLock支持锁降级，遵循按照获取写锁，获取读锁再释放写锁的次序，写锁能够降级成为读锁，不支持锁升级。解读在最下面:
      请添加图片描述
    3. 解读：
      1. 代码中声明了一个volatile类型的cacheValid变量，保证其可见性。
      2. 首先获取读锁，如果cache不可用，则释放读锁，获取写锁，在更改数据之前，再检查一次cacheValid的值，然后修改数据，将cacheValid置为true，然后在释放写锁前获取读锁；此时，cache中数据可用，处理cache中数据，最后释放读锁。这个过程就是一个完整的锁降级的过程，目的是保证数据可见性。
      3. 如果违背锁降级的步骤 如果当前的线程C在修改完cache中的数据后，没有获取读锁而是直接释放了写锁，那么假设此时另一个线程D获取了写锁并修改了数据，那么C线程无法感知到数据已被修改，则数据出现错误。
      4. 如果遵循锁降级的步骤 线程C在释放写锁之前获取读锁，那么线程D在获取写锁时将被阻塞，直到线程C完成数据处理过程，释放读锁。这样可以保证返回的数据是这次更新的数据，该机制是专门为了缓存设计的。

14.2 邮戳锁（版本锁）

  1. 比读写锁更快的锁与锁饥饿问题相关优化
  2. 是什么？
    1. StampedLock是JDK1.8中新增的一个读写锁，也是对JDK1.5中的读写锁ReentrantReadWriteLock的优化。
    2. 邮戳锁，也叫票据锁
    3. stamp （戳记， Iong类型）：代表了锁的状态。当stamp返回零时，表示线程获取锁失败。并且，当释放锁或者转换锁的时候，都要传入最初获取的stamp值。
    4. 解决问题：写锁饥饿问题；公平策略可以解决，但是牺牲了吞吐量
  3. StampedLock类的乐观读锁闪亮登场
    1. ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。但是，StampedLock采取乐观获取锁后，其他线程尝试获取写锁时不会被阻塞，这其实是对读锁的优化，所以，在获取乐观读锁后，还需要对结果进行校验。
    2. 简单说：读锁默认不会有写锁对数据进行修改，但是读完会校验版本，如果被改了则此次读作
  4. StampedLock特点：
    1. 所有获取锁的方法，都返回一个邮戳（Stamp)，Stamp为零表示获取失败，其余都表示成功：
    2. 所有释放锁的方法，都需要一个邮戳（Stamp），这个Stamp必须是和成功获取锁时得到的Stamp一致：
    3. StampedLock是不可重入的，危险(如果一个线程己经持有了写锁，再去获取写锁的话就会造成死锁）
    4. StampedLock有三种访问模式
      1. Reading（读模式悲观）：功能和ReentrantReadWriteLock的读锁类似
      2. Writing（写模式）：功能和ReentrantReadWriteLock的写锁类似
      3. Optimistic reading（乐观读模式）：无锁机制，类似于数据库中的乐观锁，支持读写并发，很乐观认为读取时没人修改，假如被修改再实现升级为悲观读模式
  5. API：基本和读写锁一致，多了一个validate校验方法
  6. 代码演示：

    1. stampedLock完全可以作为读写锁用：

      //悲观读
public void read() {
        long stamp = stampedLock.readLock();
        System.out.println(Thread.currentThread().getName()+"\t come in readlock block,4 seconds continue...");
        //暂停4秒钟线程
        for (int i = 0; i <4 ; i++) {
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t 正在读取中......");
        }
        try {
            int result = number;
            System.out.println(Thread.currentThread().getName()+"\t"+" 获得成员变量值result：" + result);
            System.out.println("写线程没有修改值，因为 stampedLock.readLock()读的时候，不可以写，读写互斥");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            stampedLock.unlockRead(stamp);
        }
    }

public void write() {
        long stamp = stampedLock.writeLock();
        System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程准备修改");
        try {
            number = number + 13;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            stampedLock.unlockWrite(stamp);
        }
        System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程结束修改");
}

public static void main(String[] args) {
        StampedLockDemo resource = new StampedLockDemo();

        //1 悲观读,和ReentrantReadWriteLock一样
        new Thread(() -> {
            //悲观读
            resource.read();
        },"readThread").start();

        new Thread(() -> {
            resource.write();
        },"writeThread").start();
}

修改是失败的，读取成功

    2. 乐观读：

      // 乐观读
public void tryOptimisticRead() {
    long stamp = stampedLock.tryOptimisticRead();
    // 先把数据取得一次
    int result = number;
    // 间隔4秒钟，我们很乐观的认为没有其他线程修改过number值，愿望美好，实际情况靠判断。
    System.out.println("4秒前stampedLock.validate值(true无修改，false有修改)" + "\t" + stampedLock.validate(stamp));
    for (int i = 1; i <= 4; i++) {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "\t 正在读取中......" + i +
                "秒后stampedLock.validate值(true无修改，false有修改)" + "\t"
                + stampedLock.validate(stamp));
    }
    if (!stampedLock.validate(stamp)) {
        System.out.println("有人动过--------存在写操作！");
        // 有人动过了，需要从乐观读切换到普通读的模式。
        stamp = stampedLock.readLock();
        try {
            System.out.println("从乐观读 升级为 悲观读并重新获取数据");
            // 重新获取数据
            result = number;
            System.out.println("重新悲观读锁通过获取到的成员变量值result：" + result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            stampedLock.unlockRead(stamp);
        }
    }
    System.out.println(Thread.currentThread().getName() + "\t finally value: " + result);
}
  7. stampedLock缺点：
    1. StampedLock 不支持重入，没有Re开头
    2. StampedLock 的悲观读锁和写锁都不支持条件变量（Condition），这个也需要注意。
    3. 使用 StampedLock一定不要调用中断操作，即不要调用interrupt( )方法
Parzivval
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC线程高级
02-27
JUC线程高级,
JUC高级-0614
lannister_awalys_pay的博客
06-15 858
线程中断；lockSupport；JMM；volatile
JUC高级-0608
lannister_awalys_pay的博客
06-13 523
前置知识；线程基础；completableFuture；多线程锁初步
剑指JUC原理-2.线程
爱吃知识的土豆倪的博客
10-25 154
Thread是把线程和任务合并在了一起，Runnable是把线程和任务分开了用 Runnable 更容易与线程池等高级 API 配合用 Runnable 让任务类脱离了 Thread 继承体系，更灵活。
JUC基础---跟着狂神学习系列
weixin_51304123的博客
08-04 201
JUC1、JUC是什么2、进程与线程并行，并发sleep与wait区别3、锁传统的Synchronized锁LOCK锁传统的Synchronized锁与LOCK锁对比虚假唤醒4、生产者消费者模式5、八锁现象6、集合类不安全CopyOnWriteArrayListCopyOnWriteArraySetConcurrentHashMap7、Callable8、常用辅助类CountDownLatch(减法计数器)CyclicBarrier(加法计数器)Semaphore(信号量)9、读写锁（ ReadWriteL
22 尚硅谷Java JUC线程高级视频
08-07
教程视频：在 Java 5.0 提供了 java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类, 用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文...
JAVA线程高级-线程按序交替执行
11-01
java多线程按需交替执行，java新特性。
thread.zip--狂神多线程+juc
03-18
B站狂神说Java的多线程基础篇+juc高级篇代码
尚硅谷Java视频_JUC 视频教程
02-17
尚硅谷_JUC线程高级_源码、课件　·1. 尚硅谷_JUC线程高级_volatile 关键字与内存可见性 ·2. 尚硅谷_JUC线程高级_原子变量与 CAS 算法 ·3. 尚硅谷_JUC线程高级_模拟 CAS 算法 ·4. 尚硅谷_JUC线程高级_同步容器类...
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 951
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 894
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 813
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
Java解决最长公共前缀
无人罪的博客
04-28 231
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 447
待更新。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 900
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 730
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
【限流】基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
最新发布
qq_43209531的博客
04-30 199
基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
Java设计模式_概述（设计模式类型和基本原则）
weisian的博客
04-25 870
通过合成，可以将已有的类组合成新的类，达到复用的目的，同时保持类的简单和清晰。设计模式（Design pattern）代表了最佳的实践，是软件开发人员在软件开发过程中面临一般问题的解决方案，是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。但不推荐刚入门的开发者学习，哪怕把代码搞的一塌糊涂，也要先将功能完成，初学者，迈过坑是必然的，只有对自己编写的代码不满意，你才会体会到设计模式的重要性，也才能更加理解。也就是说，一个类应该尽量减少与其他类的耦合度，只与它直接相关的类进行交互。
狂神说java-juc并发编程
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent...java.util.concurrent包则提供了一些高级的并发工具类，如CountDownLatch、CyclicBarrier、Semaphore等，用于协调多个线程的执行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值