CAS机制详解

努力发光的程序员

已于 2023-07-21 14:55:08 修改

阅读量380

点赞数

文章标签： java juc

于 2023-07-14 18:12:23 首次发布

本文链接：https://blog.csdn.net/iloveyouwh/article/details/131729428

版权

一、是什么

CAS，是Compare and Swap的简称，实现并发算法是常用到的一种技术，在这个机制中有三个核心的参数。

主内存中存放的共享变量的值：V（一般情况下这个V是内存的地址值，通过这个地址可以获得内存中的值）。
工作内存中共享变量的副本值，也叫预期值：A。
需要将共享变量更新到的最新值：B。

在这里插入图片描述

CAS是JDK提供的非阻塞原子性操作，它通过硬件保证了比较-更新的原子性。CAS是一条CPU的原子指令（cmpxchg指令），不会造成所谓的数据不一致问题，Unsafe提供的CAS方法。

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

二、能做什么

CAS是一种乐观锁机制,它不会阻塞线程, 先从内存位置读取到值，然后和预期值比较。这种机制在不阻塞其他线程的情况下避免了并发冲突，比独占锁的性能高很多。

三、自旋锁

CAS是实现自旋锁的基础，CAS利用CPU指令保证了操作的原子性，以达到锁的效果。自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，当线程发现锁被占用是，会不断判断锁的状态，直到获取。这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU

下面我们将利用CAS的思想来自己写一个自旋锁。

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)){
            
        }
    }
    public void unlock(){
        Thread thread=Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName()+"\t invoked unlock");
    }
    public static void main(String[] args) {
        SpinLockDemo spinLockDemo=new SpinLockDemo();
        new Thread(()->{
            spinLockDemo.lock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            spinLockDemo.unlock();
        },"t1").start();
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(()->{
            // 只有当线程t1释放锁，t2才能获取锁，t2会一直处于自旋转态
            spinLockDemo.lock();
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            spinLockDemo.unlock();
        },"t2").start();
    }
}

四、CAS的缺点

循环时间长开销很大。
引起ABA问题。

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

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

五、ABA问题

下面我将用问提来分析ABA问题对于实际开发中的影响。

假设小琳银行卡有 100 块钱余额，且假定银行转账操作就是一个单纯的 CAS 命令，对比余额旧值是否与当前值相同，如果相同则发生扣减/增加，我们将这个指令用 CAS(origin,expect) 表示。于是，我们看看接下来发生了什么：

小琳在 ATM 1 转账 100 块钱给小李；
由于ATM 1 出现了网络拥塞的原因卡住了，这时候小琳跑到旁边的 ATM 2 再次操作转账；
ATM 2 没让小琳失望，执行了 CAS(100,0)，很痛快地完成了转账，此时小琳的账户余额为 0；
小王这时候又给小琳账上转了 100，此时小琳账上余额为 100；
这时候 ATM 1 网络恢复，继续执行 CAS(100,0)，居然执行成功了，小琳账户上余额又变为了 0；
这时候小王微信跟小琳说转了 100 过去，是否收到呢？小琳去查了下账，摇了摇头，那么问题来了，钱去了哪呢？

关于钱的去向，有一种可能就是小王给小琳的 100 大洋，因为 ATM 1 网络恢复再次被转给了小李，毕竟小琳尝试了两次转账，出现这种情况虽不合理，但情有可原。假设我们作为银行系统设计者和开发者，不接受这种情况存在，那我们就需要着手处理这种 ABA 问题了。

public class ABADemo {
    static int NUM=100;
    static AtomicInteger stock=new AtomicInteger(NUM);
    public static void main(String[] args) {
       // ATM1转账100，因为网络问题延时转账
        new Thread(()->{
            // ATM2转账100，立刻转出
            boolean b = stock.compareAndSet(stock.get(), stock.get() - 100);
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            // 因为网络问题延时转账
            // 成功转账
            stock.compareAndSet(stock.get(),stock.get()-100);
            System.out.println("剩余金额"+stock.get());
        },"t1").start();

        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        // 小王转账100
        new Thread(()->{
            // 库存+1
            stock.compareAndSet(stock.get(),stock.get()+100);
        },"t3").start();
    }
}

我门可以用AtomicStampedReference来解决ABA问题相当于就是加了一个版本号。

public class ABADemo {
    static int NUM=100;
    static AtomicInteger stock=new AtomicInteger(NUM);
    static AtomicStampedReference<Integer> stampedReference=new AtomicStampedReference<>(100,1);
    public static void main(String[] args) {

        new Thread(()->{
            int stamp = stampedReference.getStamp();
            // 成功转账
            boolean b2 = stampedReference.compareAndSet(stampedReference.getReference(), stampedReference.getReference() - 100, stamp, stamp + 1);
            System.out.println("ATM2转账是否成功"+b2);
            // 因为网络问题延时转账
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            // ATM1转账100，因为网络问题延时转账
            boolean b1 = stampedReference.compareAndSet(stampedReference.getReference(), stampedReference.getReference() - 100, stamp, stamp + 1);
            System.out.println("ATM1转账是否成功"+b1);
            System.out.println("剩余金额"+stampedReference.getReference());
        },"t1").start();

        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        // 小王转账100
        new Thread(()->{
            // 库存+1
            boolean b = stampedReference.compareAndSet(stampedReference.getReference(), stampedReference.getReference() + 100, stampedReference.getStamp(), stampedReference.getStamp() + 1);
            System.out.println("小王转账是否成功"+b);
        },"t3").start();


    }
}

本案列是在网上的一个项目，ABA问题在实际业务中的影响作者暂时还没有经历，如遇到希望有机会可以和大家讨论一下。