【CAS】解释下CAS，CAS刨析

最新推荐文章于 2022-08-22 02:01:13 发布

付三三_

最新推荐文章于 2022-08-22 02:01:13 发布

阅读量376

点赞数

分类专栏：技术-并发类文章标签： AtomicInteger CAS 时间戳原子引用并发

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/qq_30546099/article/details/112614484

版权

技术-并发类专栏收录该内容

10 篇文章 0 订阅

订阅专栏

由上一篇volatile(https://blog.csdn.net/qq_30546099/article/details/112607448)引出的问题：volatile的其中一条特性是非原子性，解决非原子性其中一条是用juc下的AtomicInteger解决，那AtomicInteger又是什么呢，原理是什么呢？这就引出了CAS。Atomic的底层实现原理是CAS

【问题一】CAS是什么？

解释下大概意思，详细的描述就不说了，百度一搜一大把。CAS：比较并交换 CompareAndSet，也就是如果线程的期望值和物理内存的真实值一样，比较为true，则修改为更新值；若不一样，false，则修改失败，需要重新获得主物理内存的真实值再比较，直到成功。（若是不太明白，请查看第一句提到的volatile中的文章，里面有介绍JMM，可以看下）

CAS应用

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

可以自己手动写一个小demo感受一下

package com.neu.controller.study;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * CAS比较并交换
 */
public class CASDemo {
    public static void main(String[] args) {
        //初始值 5
        AtomicInteger atomicInteger = new AtomicInteger(5);
        //期望值 5 ，
        System.out.println(atomicInteger.compareAndSet(5, 2019)+"\t current data "+atomicInteger.get());//主物理内存值是5，期望值也是5，修改为2019，成功
        System.out.println(atomicInteger.compareAndSet(5, 1024)+"\t current data "+atomicInteger.get());//主物理内存值目前变为2019，期望值是5，比较不成功，失败
//        atomicInteger.getAndIncrement();//i++
    }
}

运行结果：

true current data 2019
false current data 2019

【问题二】CAS的底层底层实现原理是什么？谈谈对UnSafe的理解？

unsafe类+CAS思想（自旋）

那unsafe类是什么？来自JVM的rt.jar

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

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

所以stomicInteger原子整型之所以在i++中操作，在多线程中操作不用加synchronzied也能保证线程的安全，是因为他用的是unsafe类。

那么解决i++在多线程情况下线程安全的问题，可以用getAndIncrement方法

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);//this 当前对象；valueOffetset：内存地址偏移量，内存地址；1：加1
}

查看基本源码，CAS思想

v1就是对象；v2该对象的引用地址；v4需要变动的数量；v5通过v1，v2找出的主内存中真实的值；用该对象当前的值与v5比较，若相同更新v5+v4并且返回true，若不同，继续取值然后再比较，直到更新完成。

v1中的v2的地址值的真实初始值是v5.

v1中的v2地址的地址的值还是不是v5，就是和v5进行比较，一样，那就修改v5+v4

While（false）刚好比较成功了，跳出循环，初始值就是v5

while（true）在获取下最新值v5是森么

getAndIncrement调的是unsafe方法（当前对象，这个对象的内存地址，要修改的值）

这个对象的内存地址调的是CAS的底层思想，比较成功了就修改，比较失败了重新比较在修改

【问题三】CAS的运行原理解释？

如上图解释下unsafe.getAndAddInt

假设线程A和线程B两个线程同时执行getAndAddInt操作（分别跑到不同CPU上）

1.AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的value原始值为3，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B各自持有一个价值为3的value的副本分别到各自的工作内存。

2.线程A通过getIntVolatile(var1,var2)拿到value值3，这时线程A被挂起。

3.线程B也通过getIntVolatile(var1,var2)方法获取到value值3，此时刚好线程B没有被挂起并执行compareAndSwapInt方法比较内存值也为3，成功修改内存值为4，线程B修改完ok。

4.这时线程A恢复，执行compareAndSwapInt方法比较，发现自己手里的值数字3和主内存的值数字4不一致，说明该值已经被其他线程抢先一步修改过了，那A线程本次修改失败，只能重新读取重来一遍了。

5.线程A重新获取value值，因为变量value被volatile修饰，所以其他线程对它的修改，线程A总是能够看到，线程A继续执行compareAndSwapInt进行比较替换，直到成功。

【问题四】CAS的缺点？

上面知道了CAS是什么，运行原理是什么之后，我们要了解它的缺点，从以下几个方面去了解。

1.循环时间长开销大。do...while，如果CAS失败，会一直进行尝试，若一直不成功，可能回给CPU带来很大的开销。

2.只能保证一个共享变量的原子操作。

当对一个共享变量执行操作时，我们只能使用循环CAS的方式来保证原子操作，但是，对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁来保证原子性。

3.引出来ABA问题。

【问题五】ABA问题是什么？如何规避？

CAS算法实现一个重要前提需要取出来内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差类会导致数据的变化。

举个例子：比如说一个线程1从内存位置V中取出A，这时候另一个线程2也从内存中取出A，并且线程2进行了一些操作将值变为了B，然后线程2又将V位置得数据又变为了A，这时候线程1进行CAS操作发现内存中仍然是A，然后线程1操作成功。

尽管线程1的CAS操作成功，但是不代表这个过程就是没问题的。最终主内存中的真实值A是由A-B-A变换来的。

那如何解决ABA问题呢？

时间戳原子引用AtomicStampedReference<V>，也就是原子引用+修改版本号（类似于时间戳）

跑一个小demo运行看下

package com.neu.controller.study;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;
public class ABAdEMO {
    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);//会导致ABA问题
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100,1);//解决ABA问题
    public static void main(String[] args) {
        System.out.println("============以下是ABA问题的产生==========");
        new Thread(()->{
            atomicReference.compareAndSet(100,101);
            atomicReference.compareAndSet(101,100);

        },"t1").start();

        new Thread(()->{
            //暂停1秒钟 t2线程 保证t1完成了一次ABA操作
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100, 2019)+"\t "+atomicReference.get());
        },"t2").start();

        try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) { e.printStackTrace();}
        System.out.println("===========以下是ABA问题的解决===========");

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();//版本号
            System.out.println(Thread.currentThread().getName()+"\t第1次版本号："+stamp);
            //暂停1秒钟 t3线程
            try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) { e.printStackTrace();}
            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());
        },"t3").start();


        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();//版本号
            System.out.println(Thread.currentThread().getName()+"\t第1次版本号："+stamp);
            //暂停3秒钟 t3线程 保证t1完成了一次ABA操作
            try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) { e.printStackTrace();}
            boolean result = atomicStampedReference.compareAndSet(100,2019,stamp,stamp+1);

            System.out.println(Thread.currentThread().getName()+"\t是否修改成功："+result+"  当前版本号："+atomicStampedReference.getStamp());
            System.out.println("当前实际最新值："+atomicStampedReference.getReference());
        },"t4").start();
    }
}

运行结果

============以下是ABA问题的产生==========
true   2019
===========以下是ABA问题的解决===========
t3   第1次版本号：1
t4   第1次版本号：1
t3   第2次版本号：2
t3   第3次版本号：3
t4   是否修改成功：false 当前版本号：3
当前实际最新值：100

AtomicStampedReference的最终目的就是在每次修改的数据上加一个版本号，若值虽然相同，但是版本号不同，则修改还是失败。就可以解决CAS导致的ABA问题了。

【问题六】讲一讲AtomicInteger，为什么要用CAS而不是synchronized？

我们都知道AtomicInteger的实现原理是CAS，但是为什么要用CAS而不是synchronized。

因为synchronized加锁同一时间段只有一个线程来访问，一致性得到了保障，但是并发性下降，而CAS底层用的是do..while，可以反复的通过CAS比较，直到比较成功为止。这样既保证了一致性，又提高了并发性。

付三三_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
【CAS】解释下CAS，CAS刨析

由上一篇volatile(https://blog.csdn.net/qq_30546099/article/details/112607448)引出的问题：volatile的其中一条特性是非原子性，解决非原子性其中一条是用juc下的AtomicInteger解决，那AtomicInteger又是什么呢，原理是什么呢？这就引出了CAS。Atomic的底层实现原理是CAS【问题一】CAS是什么？解释下大概意思，详细的描述就不说了，百度一搜一大把。CAS：比较并交换 CompareAndSet，也就是如
复制链接

扫一扫