【JUC并发编程系列】深入理解Java并发机制：CAS算法与原子类在Java中的实践应用(二、CAS)

embedded/2024/9/23 3:54:37/

文章目录

  • 【JUC并发编程系列】深入理解Java并发机制：CAS算法与原子类在Java中的实践应用(二、CAS)
    • 1. 同步之原子类（Atomic类）
    • 2. 使用atomicInteger计数
    • 3. 使用atomicInteger底层原理
    • 3. compareAndSet原理分析
      • 3.1 手写AtomicInteger
      • 3.2 手写Lock锁
      • 3.3 CAS aba的问题
      • 3.4 AtomicMarkableReference
    • 4. CAS 优点
    • 5. 悲观锁与乐观锁
      • 5.1 悲观锁
      • 5.2 乐观锁

JUCJavaCASJavaCAS_1">【JUC并发编程系列】深入理解Java并发机制：CAS算法与原子类在Java中的实践应用(二、CAS)

CAS: Compare and Swap，翻译成比较并交换。底层会执行函数CAS（V，E,N）

CAS有3个操作数，内存值V，旧的预期值E，要修改的新值N。当且仅当预期值E和内存值V相同时，将内存值V修改为N，否则什么都不做。

保证线程安全性的问题 原子性

（V，E，N）===乐观锁

V：全局共享变量 原子类中 value值 ===0

E：旧的预期值

N：修改的新值

CAS：无锁机制----自旋控制乐观锁

缺点：自旋会消耗的cpu的资源 cas 死循环 空转问题 cpu飙高

底层基于unsafe类实现

img

里面的 unsafe.getAndAddInt(this, valueOffset, 1)中的

  • this===atomicInteger 对象；
  • valueoffset ==值偏移量；
  • 1
java">public final int getAndAddInt(Object paramObject, long paramLong, int paramInt) {//循环目的 就是为了cas的重试while (true) {//paramObject=atomicInteger 对象//Valueoffset ==值偏移量；//根据 this 和 valueOffset 获取当前的 atomicInteger 中 value值int i = getIntVolatile(paramObject, paramLong);//i=0if (compareAndSwapInt(paramObject, paramLong, i, i + paramInt))return i;}
}

1. 同步之原子类（Atomic类）

属于Java并发包类库（原子类 cas）

比如我们所学习的：原子类同步之原子类（Atomic类）

  1. 原子更新基本类型类 cas

    • AtomicBoolean: 原子更新布尔类型。
    • AtomicInteger: 原子更新整型。
    • AtomicLong: 原子更新长整型。

  2. 原子更新数组

    • AtomicIntegerArray: 原子更新整型数组里的元素。
    • AtomicLongArray: 原子更新长整型数组里的元素。
    • AtomicReferenceArray: 原子更新引用类型数组里的元素。

  3. 原子更新引用类型

    • AtomicReference: 原子更新引用类型。
    • AtomicReferenceFieldUpdater: 原子更新引用类型的字段。
    • AtomicMarkableReferce: 原子更新带有标记位的引用类型，可以使用构造方法更新一个布尔类型的标记位和引用类型。

  4. 原子更新字段类

    • AtomicIntegerFieldUpdater: 原子更新整型的字段的更新器。
    • AtomicLongFieldUpdater: 原子更新长整型字段的更新器。
    • AtomicStampedFieldUpdater: 原子更新带有版本号的引用类型。

  5. JDK8新增原子类

    • DoubleAccumulator:DoubleAccumulator 是一个用于累积双精度浮点数的原子类。它允许通过一个给定的组合函数来原子地累加值。这个类通常用于并行计算场景，例如并行流处理中的数值累积。

    • LongAccumulator:类似于 DoubleAccumulator，LongAccumulator 用于累积长整型数值。它也支持通过一个组合函数原子地累加值，适用于需要在无锁情况下对长整型数据进行并行累加的场景。

    • DoubleAdder:DoubleAdder 是一个专门用于原子地累加双精度浮点数的类。与 DoubleAccumulator 不同，DoubleAdder 默认使用加法作为组合函数，因此它简化了累加操作。它适用于需要快速并行累加双精度值的场景。

    • LongAdder:LongAdder 与 DoubleAdder 类似，但用于长整型数值。它提供了原子的累加操作，适合在高并发环境下快速累加长整型数据。

    Java 层面是由 Unsafe 类实现的

2. 使用atomicInteger计数

java">public class Test01 extends Thread {//value == 0private static AtomicInteger atomicInteger = new AtomicInteger(0);@Overridepublic void run() {sum();}private static void sum() {for (int i = 0; i < 1000; i++) {//value++atomicInteger.incrementAndGet();}}public static void main(String[] args) throws InterruptedException {Test01 t1 = new Test01();Test01 t2 = new Test01();t1.start();t2.start();t1.join();t2.join();System.out.println(atomicInteger.get());}
}

atomicInteger 计数能够保证线程安全问题。

3. 使用atomicInteger底层原理

atomicInteger底层基于CAS实现

image-20240722214944560

Unsafe类，全限定名是sun.misc.Unsafe，从名字中我们可以看出来这个类对普通程序员来说是“危险”的，一般应用开发者不会用到这个类。

Unsafe类是"final"的，不允许继承。且构造函数是private的

传递三个参数 【this（atomicInteger this） valueOffset（成员变量在内存中偏移量） ,1 】+1

Value=对象内存地址+内存偏移量

CAS前置知识Unsafe

Unsafe对象提供了非常底层的，操作内存、线程的方法，Unsafe 对象不能直接调用，只能通过反射获得 java9已经移除Unsafe

Cas底层 Unsafe类实现-----java层面

Cas 能够保证线程安全性 数据的原子性------cpu硬件支撑

java">public class Test04 {private static AtomicInteger atomicInteger = new AtomicInteger();public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {// 1.使用反射获取theUnsafe属性Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");theUnsafe.setAccessible(true);//设置可以访问私有属性// 2.获取到unsafeUnsafe unsafe = (Unsafe) theUnsafe.get(null);// 1.获取域的偏移地址long idOffset = unsafe.objectFieldOffset(Lock.class.getDeclaredField("state"));Lock lock = new Lock();// 获取 state 字段的偏移量long idOffset = unsafe.objectFieldOffset(Lock.class.getDeclaredField("state"));/*** Object o 想要修改的对象* long offset 需要修改字段的偏移值* int expected 旧的预期值* int x 拟修改的值*/boolean result = unsafe.compareAndSwapInt(lock, idOffset, 0, 1);System.out.println(result);}static class Lock {int state;}
}

java">public final int getAndAddInt(Object paramObject, long paramLong, int paramInt) {while (true) {int i = getIntVolatile(paramObject, paramLong);if (compareAndSwapInt(paramObject, paramLong, i, i + paramInt))return i;}
}

从对象的内存处开始，获得原始字节偏移量，用于存储实力对象的内存

在这里偏移量的意思就像我们 new 一个数组，数组的地址就是数组地一个元素的地址，假如数组地址是 a，第二个元素就是a+1,其中+1就是偏移量。对应的对象的一个属性的偏移量就是其对象的地址开始增加，增加的数就是这个filed的偏移量。

对于value这个值我们知道了，他是AtomicInteger中的value属性对应的偏移量，就是对象地址+value = value的地址

循环：获取当前atomicInteger 原子类的 value=0 i=0

compareAndSwapInt(1,1,1+1);

img

AtomicInteger 底层如何实现:

  1. 创建了一个AtomicInteger 类
  2. 先定义一个 int类型value值
  3. 底层都是基于unsafe类实现

AtomicInteger源码：

java">/***就是对旧的预期值 +1*/
public final int incrementAndGet() {return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
//参数1 this new AtomicInteger 
//参数2  valueOffset
//参数3  1public final int getAndAddInt(Object var1, long var2, int var4) {int var5;do { // var5 获取最新的 value 值 即当前值 （旧预期值 E） AtomicInteger类中的 value 字段加上了volatile 关键字var5 = this.getIntVolatile(var1, var2);//this.compareAndSwapInt(var1, var2, var5, var5 + var4)//var1 this new AtomicInteger 对象//var2 value的值 offset//var5---当前value值=0 （旧预期值 E）//var5（0） + var4（1）---当前value值+1} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));return var5;
}

3. compareAndSet原理分析

compareAndSet(e,n);

E==V 则将N的值赋值给V；

3.1 手写AtomicInteger

java">public class TestAtomicInteger {/*** 自动实现自增 并且不发生线程安全性问题*/private static AtomicInteger atomicInteger = new AtomicInteger(0);public int incrementAndGet() {//返回新的 valuereturn getAndAddInt() + 1;}public int getAndAddInt() {//对当前的全局变量值 value++//获取旧的预期值int expect = atomicInteger.get();//此段代码会引起 cpu 飙高的问题while (true) {if (atomicInteger.compareAndSet(expect, expect + 1)) {return expect;}try {//休眠 100 毫秒 避免 cpu 飙高的问题Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}}}public static void main(String[] args) {
//        boolean result = atomicInteger.compareAndSet(0, 2);
//        System.out.println(result+","+atomicInteger.get());TestAtomicInteger testAtomicInteger = new TestAtomicInteger();testAtomicInteger.incrementAndGet();testAtomicInteger.incrementAndGet();testAtomicInteger.incrementAndGet();System.out.println(atomicInteger.get());}
}

3.2 手写Lock锁

java">public class TestLock {/*** initialValue = 0 表示没有线程使用* initialValue = 1 表示有一个线程正在使用*/private AtomicInteger lockState = new AtomicInteger(0);/*** 获取锁*/public void lock() {/*** 将 initialValue 从 0 => 1* 如果有两个线程同时获取锁，最终只会有一个线程获取成功* 没有获取到锁会进行自旋*/while (true) {if (lockState.compareAndSet(0, 1)) {return;}try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}}}/*** 释放锁*/public void unlock() {while (true) {if (lockState.compareAndSet(1, 0)) {return;}try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}

java">public class Test05 implements Runnable {private TestLock testLock = new TestLock();private static int count = 100;@Overridepublic void run() {while (true) {try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}cal();}}public void cal() {try {//获取锁testLock.lock();if (count > 1) {count--;System.out.println(Thread.currentThread().getName() + "count=" + count);}} catch (Exception e) {} finally {//释放锁testLock.unlock();}}public static void main(String[] args) {Test05 test05 = new Test05();new Thread(test05).start();new Thread(test05).start();}
}

CAS_aba_384">3.3 CAS aba的问题

Cas主要检查 内存值V与旧的预值值=E是否一致，如果一致的情况下，则修改。

这时候会存在ABA的问题：如果将原来的值A,改为了B，B又改为了A 发现没有发生变化，实际上已经发生了变化，所以存在Aba问题。

解决办法：通过版本号码，对每个变量更新的版本号码做+1

解决aba问题是否大：概念产生冲突，但是不影响结果，换一种方式 通过版本号码方式。

img

3.4 AtomicMarkableReference

  • 第一个参数expectedReference：表示预期值。

  • 第二个参数newReference：表示要更新的值。

  • 第三个参数expectedStamp：表示预期的时间戳。

  • 第四个参数newStamp：表示要更新的时间戳。

java">public class Test004 {// 注意：如果引用类型是Long、Integer、Short、Byte、Character一定一定要注意值的缓存区间！// 比如Long、Integer、Short、Byte缓存区间是在-128~127，会直接存在常量池中，而不在这个区间内对象的值则会每次都new一个对象，那么即使两个对象的值相同，CAS方法都会返回false// 先声明初始值，修改后的值和临时的值是为了保证使用CAS方法不会因为对象不一样而返回falseprivate static final Integer INIT_NUM = 1000;private static final Integer UPDATE_NUM = 100;private static final Integer TEM_NUM = 200;private static AtomicStampedReference atomicStampedReference = new AtomicStampedReference(INIT_NUM, 1);public static void main(String[] args) {new Thread(new Runnable() {public void run() {Integer value = (Integer) atomicStampedReference.getReference();int stamp = atomicStampedReference.getStamp();System.out.println(Thread.currentThread().getName() + " : 当前值为：" + value + " 版本号为：" + stamp);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}// value 旧值 内存中的值   UPDATE_NUM 修改的值if (atomicStampedReference.compareAndSet(value, UPDATE_NUM, 1, stamp + 1)) {System.out.println(Thread.currentThread().getName() + " : 当前值为：" + atomicStampedReference.getReference() + " 版本号为：" + atomicStampedReference.getStamp());} else {System.out.println("版本号不同，更新失败！");}}}, "线程A").start();}
}

CAS__440">4. CAS 优点

CAS（Compare and Swap）或 Compare and Set 是一种无锁编程中常用的原子操作。它通常用于实现线程安全的数据结构和算法，而无需使用传统的互斥锁。CAS 操作的主要优点包括：

  1. 避免死锁：
    CAS 减少了因传统锁机制而导致的死锁风险。在多线程环境中，如果线程获取锁的顺序不当，就可能产生死锁。CAS 操作不需要显式地获取和释放锁，从而降低了死锁的可能性。

  2. 提高并发性能：
    CAS 操作可以并行执行，当多个线程尝试更新同一个数据时，其中一个线程会成功执行 CAS，而其他线程将失败并重试。这允许更多的线程同时进行工作，提高了系统的整体吞吐量。

  3. 低开销：
    与锁相比，CAS 操作在硬件级别上实现，通常具有更低的系统开销。锁需要维护锁定状态、等待队列等，而 CAS 只需要简单的比较和交换指令。

  4. 非阻塞性：
    使用 CAS 进行的更新是非阻塞的，这意味着即使一个线程在等待其 CAS 操作成功，它也不会阻止其他线程执行自己的 CAS 操作。这有助于保持系统的响应性和效率。

  5. 灵活性：
    CAS 操作为设计高度优化的并发算法提供了基础。开发者可以直接控制并发行为，而不必依赖于更高层次的同步原语，如锁。

  6. 支持构建更复杂的同步结构：
    利用 CAS 操作，可以构建更高级别的同步结构，如无锁队列、栈和其他数据结构，这些结构在高并发场景下表现优异。

然而，CAS 也并非没有缺点。例如，它可能导致 ABA 问题，在某些情况下需要额外的逻辑来解决。此外，过度的 CAS 失败和重试可能导致某些线程被饥饿，即无法获得更新数据的机会。在设计基于 CAS 的算法时，必须谨慎处理这些问题。

5. 悲观锁与乐观锁

5.1 悲观锁

悲观锁比较悲观，当多个线程对同一行数据实现写的操作的时候，最终只会有一个线程才能写成功，只要谁能够对获取该到行锁则其他线程时不能够对该行数据做任何修写操作，且是阻塞状态。 比如for update 或者事务开启了事务但是没有提交事务。

mysql存储引擎 InnoDB 事务

线程1 对userid=1`` update操作 开启事务 没有提交和回滚事务；

线程2 对 userid=1 update 操作 它会一直阻塞等待；

线程2 它会一直阻塞等待

  • 原因：线程1 开启了事务 没有提交和回滚事务 意味着其他的线程就不能够对该行数据做写的操作就会一直阻塞等待-----触发行锁机制

  • 目的：就是为了保证该行数据的线程安全性问题。

注意：mysql中的autocommit为自动提交。

Value的值为ON，表示autocommit开启。

OFF表示autocommit关闭

set autocommit=0;—关闭

  1. 用 BEGIN, ROLLBACK, COMMIT来实现

    • BEGIN 开始一个事务

    • ROLLBACK 事务回滚

    • COMMIT 事务确认

  2. 直接用 SET 来改变 MySQL 的自动提交模式:

  • SET AUTOCOMMIT=0 禁止自动提交

  • SET AUTOCOMMIT=1 开启自动提交

--查询当前线程对应的事务
select t.trx_mysql_thread_id from information_schema.innodb_trx t
--清理未提交的事务
kill 768;

悲观锁比较悲观 —没有获取到锁 则会阻塞等待。

Java synchronized 如果升级为重量级锁(变成悲观锁) => C++Monitor 对象

5.2 乐观锁

乐观锁比较乐观，通过预值或者版本号比较，如果不一致性的情况则通过循环控制修改，当前线程不会被阻塞，是乐观，效率比较高。

image-20240721132336183


http://www.ppmy.cn/embedded/101443.html

相关文章

刘海屏的优雅回归？华为Mate 70 Pro定义新美学

刘海屏的优雅回归？华为Mate 70 Pro定义新美学

在智能手机的发展历程中&#xff0c;华为Mate系列一直是高端旗舰的代表。而今&#xff0c;华为Mate 70 Pro的神秘面纱终于揭开&#xff0c;其回归的刘海屏设计和独特的寰宇舷窗设计&#xff0c;再次将华为的设计理念推向了新的高度。 刘海屏的回归&#xff1a;经典与创新的融合…
阅读更多...
Pytorch实现CIFAR10训练模型

Pytorch实现CIFAR10训练模型

文章目录 简述模型结构模型参数、优化器、损失函数参数初始化优化器损失函数 模型训练、测试集预测、模型保存、日志记录训练测试集测试模型保存模型训练完整代码 tensorboard训练可视化结果train_loss测试准确率测试集loss 模型应用模型独立应用代码api.py预测结果 简述 使用…
阅读更多...
5步掌握Python Django+Vue二手房项目，实现房价预测与知识图谱系统

5步掌握Python Django+Vue二手房项目，实现房价预测与知识图谱系统

&#x1f34a;作者&#xff1a;计算机毕设匠心工作室 &#x1f34a;简介&#xff1a;毕业后就一直专业从事计算机软件程序开发&#xff0c;至今也有8年工作经验。擅长Java、Python、微信小程序、安卓、大数据、PHP、.NET|C#、Golang等。 擅长&#xff1a;按照需求定制化开发项目…
阅读更多...
每日OJ_牛客_剪花布条（string内置函数）

每日OJ_牛客_剪花布条（string内置函数）

目录 牛客_剪花布条&#xff08;string内置函数&#xff09; 解析代码 牛客_剪花布条&#xff08;string内置函数&#xff09; 剪花布条__牛客网 解析代码 题意就是在S串中&#xff0c;T串整体出现了多少次。C语言可以通过strstr函数找&#xff0c;用STL的string库可以通过f…
阅读更多...
PYTORCH 官方文档，开发文档，Python编程 人工智能 深度机器学习

PYTORCH 官方文档，开发文档，Python编程 人工智能 深度机器学习

PYTORCH文档 PyTorch documentation — PyTorch master documentation PyTorch是一个使用GPU和CPU进行深度学习的优化张量库。 本文档中描述的功能按版本状态分类: 稳定:这些功能将被长期维护&#xff0c;并且在文档中通常不应该有重大的性能限制或缺口。我们还希望保持向后兼…
阅读更多...
idea debug 各个步骤含义

idea debug 各个步骤含义

基本功能 IntelliJ IDEA 的 Debug 功能提供了强大的调试支持&#xff0c;允许开发者逐步执行代码&#xff0c;检查变量值&#xff0c;评估表达式等。以下是 Debug 模式中常见的几个按钮及其含义&#xff1a; Show Execution Point (显示执行点)&#xff1a;将光标跳转到当前正在…
阅读更多...
【Google SEO】搜索引擎索引综合SEO指南

【Google SEO】搜索引擎索引综合SEO指南

有没有想过网站是如何在搜索引擎上列出的&#xff0c;以及 Google、Bing 和其他公司如何在几秒钟内为我们提供大量信息&#xff1f; 这种闪电般快速性能的秘诀在于搜索索引。它可以与所有页面的庞大且完美有序的目录档案进行比较。进入索引意味着搜索引擎已经看到了你的页面&a…
阅读更多...
UnrealEngine学习(02)：虚幻引擎编辑器界面详解

UnrealEngine学习(02)：虚幻引擎编辑器界面详解

学习一款软件&#xff0c;我个人建议是先学习怎么用&#xff0c;然后是学习怎么用的好&#xff0c;再研究源码。 上一篇文章详细描述了我们该如何安装虚幻5引擎&#xff1a; UnrealEngine学习(01)&#xff1a;安装虚幻引擎https://blog.csdn.net/zuodingquan666/article/deta…
阅读更多...
最新文章

Copyright @ 2022~2023