CAS原理及介绍

最新推荐文章于 2024-09-19 22:18:44 发布

苍山不墨

最新推荐文章于 2024-09-19 22:18:44 发布

阅读量761

点赞数 1

分类专栏： JUC 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_37032116/article/details/126726281

版权

JUC 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

CAS原理及介绍

在没有CAS之前，多线程环境下不使用原子类保证线程安全i++（基本数据类型）：加锁

使用CAS之后，在多线程环境下，可以使用原子类保证线程安全i++(基本数据类型)，类似乐观锁

什么是CAS

CAS——compare and swap，比较并交换，实现并发算法时常用到的一种技术。

它包含三个操作数——内存位置，预期原值及更新值。

执行CAS操作的时候，将内存位置的值与预期原值比较：

如果匹配，那么处理器会自动将该位置值更新为新值，如果不匹配，处理器不做任何操作或重来，多个线程同时执行CAS操作只有一个会成功。这种重来的行为叫自旋。

CAS底层原理

CAS是JDK提供的非阻塞原子性操纵，它通过硬件保证了比较-更新的原子性，更加可靠。

它的底层是一条原子指令（cmpxchg），不会造成数据不一致问题，Unsafe类提供的CAS方法（compareAndSwapXXX）地城实现都是CPU指令cmpxchg。

执行cmpxchg的时候，会判断当前系统是否为多核系统，如果是就给总线加锁，只有一个人线程会对总线枷锁成功，加锁成功后会执行cas操作，也就是说CAS的原子性实际上是CPU实现独占的，不起synchronized重量级锁，这里的排他时间要短很多，所以在多线程的情况下性能会更好。

对Unsafe的理解

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

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

变量valueOffset，表示该变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的。

变量value用volatile修饰，保证了多线程之间的内存可见性。

i++线程不安全，为什么atomicInteger.getAndIncrement()为什么安全

使用了CAS+volatile和native方法来保证原子操作，从而避免synchronized的高开销，执行效率大为提升。

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

getAndIncrement()多线程分析

假设线程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进行比较替换，直到成功。

汇编层级

JDK提供的CAS机制，在汇编层级会禁止变量两侧的指令优化，然后使用cmpxchg指令比较并更新变量值（原子性）

总结

CAS是靠硬件实现的从而在硬件层面提升效率，最底层还是交给硬件来保证原子性和可见性。

实现方式是基于硬件平台的汇编指令，在X86上使用的hi汇编指令cmpxchg

核心思想就是比较想要更新的值V和预期值E，相等才会将V的值设置为新值N，如果不相等则自旋。

原子引用

AtomicReference 泛型

自旋锁

是什么

CAS是实现自旋锁的基础，CAS利用CPU指令保证了操作的原子性，以达到加锁的效果。

至于自旋呢，看字面意思也很明白，自己旋转，是指尝试获取锁的线程不会立即阻塞而是采用循环的方式去尝试获取锁，当线程发现锁被占用时，会不断循环判断锁的状态，直到获取。

这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU

手写CAS

/*
 * 题目：实现一个自旋锁
 * 自旋锁好处：循环比较获取没有类似wait的阻塞。
 *  
 * 通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒钟，B随后进来后发现
 * 当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到。
**/
 public class SpinLockDemo
    {
        AtomicReference<Thread> atomicReference = new AtomicReference<>();

        public void Lock()
        {
            Thread thread = Thread.currentThread();
            System.out.println(Thread.currentThread().getName()+"\t"+"-----come in");
            while(!atomicReference.compareAndSet(null,thread))//用这个循环实现自旋
            {

            }
            //如果是空的，那我们把thread放进去

        }

        public void UnLock()
        {
            Thread thread = Thread.currentThread();
            atomicReference.compareAndSet(thread,null);//把当前线程踢出去，置为null
            System.out.println(Thread.currentThread().getName()+"\t"+"-------task over,unLock.....");
        }

        public static void main(String[] args)
        {
            SpinLockDemo spinLockDemo = new SpinLockDemo();
            new Thread(() -> {
                spinLockDemo.Lock();
                try { TimeUnit.SECONDS.sleep( 5 ); } catch (InterruptedException e) { e.printStackTrace(); }
                spinLockDemo.UnLock();
            },"A").start();

            //暂停一会儿线程，保证A线程先于B线程启动并完成
            try { TimeUnit.MILLISECONDS.sleep( 500); } catch (InterruptedException e) { e.printStackTrace(); }

            new Thread(() -> {
                spinLockDemo.Lock();//B  -----come in  B只是尝试去抢锁，但是一直在自旋。

                spinLockDemo.UnLock();//A结束后 B立马抢到锁，然后马上结束了
            },"B").start();

        }
    }
    //A  -----come in
    //B  -----come in
    //A  -------task over,unLock.....
    //B  -------task over,unLock.....

CAS的缺点

循环时间长开销很大

如果CAS失败，会一直进行尝试。如果CAS长时间一直不成功，可能会给CPu带来很大的开销。
ABA问题

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

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

解决思路：版本号时间戳原子引用