CAS简介

CAS 全称是 compare and swap,是一种用于在多线程环境下实现同步功能的机制。

CAS 它是一条CPU并发原语。操作包含三个操作数 -- 内存位置、预期数值和新值。CAS 的实现逻辑是将内存位置处的数值与预期数值想比较,若相等,则将内存位置处的值替换为新值。若不相等,则不做任何操作。这个过程是原子的。

CAS并发原语体现在java语言中的sun.misc.Unsafe类中的各个方法。调用Unsafe类中的CAS方法,JVM会帮我们实现汇编指令。这是一种完全依赖硬件的功能,通过它实现了原子操作。由于CAS是一种系统原语,原语属于操作系统用语范畴,是由若干条指令组成的,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许被打断,也就是说CAS是一条CPU的原子指令,不会造成所谓的数据不一致问题。

Unsafe类

Unsafe类是CAS的核心类,由于Java方法无法直接访问底层系统,需要通过本地(native)方法来访问,基于该类可以直接操作特定内存的数据。Unsafe类存在与sum.misc包中,其内部方法操作可以像C的指针一样直接操作内存,因为Java中CAS操作的执行依赖于Unsafe类的方法。

Unsafe类中的所有方法都是native修饰的,也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。

代码解析

public class CASDemo {
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(5); // 运行结果: true 2019
System.out.println(atomicInteger.compareAndSet(5, 2019) + "\t" + atomicInteger.get());
// 运行结果: false 2019
System.out.println(atomicInteger.compareAndSet(5, 1024) + "\t" + atomicInteger.get()); // 此方法可以解决多线程环境下i++问题,底层使用的是Unsafe类CAS和自旋锁
atomicInteger.getAndIncrement();
}
}

源码分析:

/**
* Atomically increments by one the current value.
*
* @return the previous value
*/
public final int getAndIncrement() {
// this=当前对象 valueOffset=内存偏移量(内存地址) 1=固定值,每次调用+1
// Unsafe就是根据内存偏移地址获取数据的。
return unsafe.getAndAddInt(this, valueOffset, 1);
} /**
* 为了方便查看和添加注释,此方法是从Unsafe类中复制出来的
*/
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
// 获取var1对象,内存地址在var2的值。
// 相当于这个线程从主物理内存中取值copy到自己的工作内存中。
var5 = this.getIntVolatile(var1, var2); // 比较并交换,如果var1对象,内存地址在var2的值和var5值一样,那么就+1
// compareAndSwapInt如果返回true,取反为false,说明更新成功,退出循环,则返回。
// compareAndSwapInt如果返回false,取反为true,说明当前线程工作内存中的值和主物理内存中的值不一样,被其他线程修改了,则继续循环获取比较,直到更新成功为止。
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); return var5;
}

执行过程说明:

  • 假设线程A和线程B两个线程同时执行 getAndAddInt操作(分别跑在不同CPU上):
  • AtomicInteger里面的value原始值为3,即主内存中 AtomicInteger的value为3,根据JMM模型,线程A和线程B各自持有一

    份值为3的value的副本分别到各自的工作内存。
  • 线程A通过 getIntVolatile(var1,var2)拿到value值3,这时线程A被挂起。
  • 线程B也通过 getIntVolatile(var1,var2)方法获取到value值3,此时刚好线程B没有被挂起并执行 compareAndSwapInt方法

    比较内存值也为3,成功修改内存值为4,线程B改完收工,一切OK。
  • 这时线程A恢复,执行 compareAndSwapInt方法比较,发现自己手里的值数字3和主内存的值数字4不一致,说明该值已

    经被其它线程抢先一步修改过了,那A线程本次修改失败,只能重新读取重新来一遍了。
  • 线程A重新获取 value值,因为变量value被 volatile修饰,所以其它线程对它的修改,线程A总是能够看到,线程A继续执

    了 compareAndSwapInt进行比较替换,直到成功。

volatile简单说明:

volatile是一个轻量级的同步机制, 三大特性: 保证可见性, 不保证原子性, 禁止指令重排。

  • 可见性: 多个线程从主内存中copy一份数据,修改后,需要将自己的数据重新写入主内存,并通知其他线程数据已更新,保证数据可见性,和多线程数据一致性。
  • 禁止指令重排: 由于指令重排,会对代码的执行顺序进行优化,可能会导致最后的结果和期望的结果不一致,所以需要禁止重排。

CAS的优缺点

优点

  • 不需要加锁,保持了一致性和并发性。

缺点

  • 循环时间长开销很大:我们可以看到getAndAddInt方法执行时,如果CAS失败,会一直进行尝试。如果CAS长时间一直不成功,可能会给CPU带来很大的开销。
  • 只能保证一个共享变量的原子操作:当对一个共享变量执行操作时,我们可以使用循环CAS的方式来保证原子操作,但是对多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候就可以用锁来保证原子性。
  • ABA问题:下面会提供详细案例

ABA问题

举个栗子说明:

主内存有个数据值:A,两个线程A和B分别copy主内存数据到自己的工作区,A执行比较慢,需要10秒, B执行比较快,需要2秒, 此时B线程将主内存中的数据更改为B,过了一会又更改为A,然后A线程执行比较,发现结果是A,以为别人没有动过,然后执行更改操作。其实中间已经被更改过了,这就是ABA问题。

也就是ABA问题只要开始时的数据和结束时的数据一致,我就认为没改过,不管过程。

尽管A线程的CAS操作是成功的,但是不代表这个过程就是没问题的。

ABA问题说简单点就是,预判值还是和当初抓取的一样,但是这个“ 值 ”的版本可能不一样了,在某些不仅要考虑数据值是否一致,还要考虑版本是否一致的场景下需要注意.

Java并发包为了解决这个问题,提供了一个带有标记的原子引用类“AtomicStampedReference”,它可以通过控制变量值的版本来保证CAS的正确性。

解决ABA问题的代码示例

/**
* 解决CAS的ABA问题
*/
public class SolveABAOfCAS { static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1); public static void main(String[] args) throws InterruptedException {
System.out.println("==========以下是ABA问题的产生==========");
new Thread(() -> {
atomicReference.compareAndSet(100, 101);
atomicReference.compareAndSet(101, 100);
}, "t1").start(); new Thread(() -> {
try {
// 暂停1秒钟,保证上面完成一次ABA操作
Thread.sleep(1000);
System.out.println(atomicReference.compareAndSet(100, 2019) + "\t" + atomicReference.get());
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "t2").start(); Thread.sleep(2000);
System.out.println("==========以下是ABA问题的解决==========");
new Thread(() -> {
int stamp = atomicStampedReference.getStamp();
System.out.println(Thread.currentThread().getName() + "\t第1次版本号" + stamp);
try {
// 暂停一秒钟t3线程
Thread.sleep(1000);
atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
System.out.println(Thread.currentThread().getName() + "\t第2次版本号" + atomicStampedReference.getStamp());
atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
System.out.println(Thread.currentThread().getName() + "\t第3次版本号" + atomicStampedReference.getStamp());
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "t3").start(); new Thread(() -> {
int stamp = atomicStampedReference.getStamp();
System.out.println(Thread.currentThread().getName() + "\t第1次版本号" + stamp);
try {
// 暂停3秒钟t4线程,保证上面的t3线程完成一次ABA操作
Thread.sleep(3000);
boolean result = atomicStampedReference.compareAndSet(100, 2019, stamp, stamp + 1);
System.out.println(Thread.currentThread().getName() + "\t修改成功否: " + result + "\t当前最新实际版本号: " + atomicStampedReference.getStamp());
System.out.println(Thread.currentThread().getName() + "\t当前实际最新值: " + atomicStampedReference.getReference());
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "t4").start(); }
}

如果觉得对你有帮助,欢迎来访我的博客:http://jianjieming.com

CAS 和 ABA 问题的更多相关文章

  1. 沉淀再出发:java中的CAS和ABA问题整理

    沉淀再出发:java中的CAS和ABA问题整理 一.前言 在多并发程序设计之中,我们不得不面对并发.互斥.竞争.死锁.资源抢占等等问题,归根到底就是读写的问题,有了读写才有了增删改查,才有了所有的一切 ...

  2. java并发编程(十三)----(JUC原子类)引用类型介绍(CAS和ABA的介绍)

    这一节我们将探讨引用类型原子类:AtomicReference, AtomicStampedRerence, AtomicMarkableReference.AtomicReference的使用非常简 ...

  3. CAS及其ABA问题

    CAS.volatile是JUC包实现同步的基础.Synchronized下的偏向锁.轻量级锁的获取.释放,lock机制下锁的获取.释放,获取失败后线程的入队等操作都是CAS操作锁标志位.state. ...

  4. Java高性能编程之CAS与ABA及解决方法

    Java高性能编程之CAS与ABA及解决方法 前言 如果喜欢暗色调的界面或者想换换界面,可以看看我在个人博客发布的 Java高性能编程之CAS与ABA及解决方法. CAS概念 CAS,全称Compar ...

  5. CAS的ABA问题详解

    CAS的ABA问题详解 ABA问题 在多线程场景下CAS会出现ABA问题,关于ABA问题这里简单科普下,例如有2个线程同时对同一个值(初始值为A)进行CAS操作,这三个线程如下 1.线程1,期望值为A ...

  6. Java并发编程入门与高并发面试(三):线程安全性-原子性-CAS(CAS的ABA问题)

    摘要:本文介绍线程的安全性,原子性,java.lang.Number包下的类与CAS操作,synchronized锁,和原子性操作各方法间的对比. 线程安全性 线程安全? 线程安全性? 原子性 Ato ...

  7. Java CAS 和ABA问题

    独占锁:是一种悲观锁,synchronized就是一种独占锁,会导致其它所有需要锁的线程挂起,等待持有锁的线程释放锁. 乐观锁:每次不加锁,假设没有冲突去完成某项操作,如果因为冲突失败就重试,直到成功 ...

  8. 无锁编程(四) - CAS与ABA问题

    CAS 一般采用原子级的read-modify-write原语来实现Lock-Free算法,其中LL和SC是Lock-Free理论研究领域的理想原语,但实现这些原语需要CPU指令的支持,非常遗憾的是目 ...

  9. 谈论高并发(十二)分析java.util.concurrent.atomic.AtomicStampedReference看看如何解决源代码CAS的ABA问题

    于谈论高并发(十一)几个自旋锁的实现(五岁以下儿童)中使用了java.util.concurrent.atomic.AtomicStampedReference原子变量指向工作队列的队尾,为何使用At ...

随机推荐

  1. S3C2440之存储控制器学习记录

    /==========翻译S3C2440存储控制器部分================/ 5 存储控制器 概述 S3C2440内存控制器为外部存储访问提供内存控制信号. S3C2440A有如下特征: ...

  2. Apache Kafka(十二)Log Cleanup 策略

    Log Cleanup 策略 在Kafka中,存在数据过期的机制,称为data expire.如何处理过期数据是根据指定的policy(策略)决定的,而处理过期数据的行为,即为log cleanup. ...

  3. EAC3 channel & program extension

    EAC3 bit stream syntax允许在single bitstream中存在time-multiplexed substreams. 在EAC3的signle bitstream中,允许s ...

  4. 每天进步一点点------Allegro PCB命名规则

    PCB命名规则-allegro 一.焊盘命名规则 1. 贴片矩形焊盘  命名规则:SMD+长(L)+宽(W)(mil) 举例:SMD90X60 2. 贴片圆焊盘   命名规则:SMDC+焊盘直径(D) ...

  5. 每天进步一点点------Xilinx DCM

    时钟---锁相环 1.       Xilinx DCM 数字时钟管理模块(Digital Clock Manager,DCM)是基于Xilinx的其他系列器件所采用的数字延迟锁相环(DLL,Dela ...

  6. Dockerfile书写介绍及构建ssh镜像、tomcat镜像、nginx镜像

    =================================================================================================== ...

  7. java 中使用logback日志,并实现日志按天分类压缩保存。

    以maven项目作为构建工具为例,首先引入使用logback需要的3个依赖,需要注意使用logback是需要引入slf4j-api的,因为logback是基于slf4j的 <!--logback ...

  8. 【转载】Mapreduce实现自定义的InputFormat

    转自:http://www.cnblogs.com/dlutxm/archive/2011/09/30/2196653.html 在mapreduce程序运行的开始阶段,hadoop需要将待处理的输入 ...

  9. zookeeper linux分布式部署

    安装包下载地址:http://mirror.bit.edu.cn/apache/zookeeper,记住要下载那个bin的不要下tar.gz包不然即使你安装了也会报错误: 找不到或无法加载主类org. ...

  10. Codeforces Global Round 3:B. Born This Way

    Born This Way原文链接:[传送门] 题目大意:潇洒哥想乘坐飞机从A地到达C地,但是没有直达的航班,在A地和B地之间有一个可以中转的航班B,潇洒哥想早点到达C地(有航班就坐),但是很不幸他得 ...