CAS浅析

Posted 2021-03-06 zhangxinying

1、CAS是什么

CAS就是compareAndSwap的缩写即我们所说的比较交换。cas是一种基于锁的操作。而且是乐观锁。

先看一个代码

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    public static void main(String[] args) {
        checkCAS();
    }

    private static void checkCAS() {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        System.out.println(atomicInteger.compareAndSet(5, 2019) + "	 current data is " + atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(5, 2014) + "	 current data is " + atomicInteger.get());
    }
}

结果

true     current data is 2019
false    current data is 2019

再看图

大致理解：主物理内存是5，t1和t2线程从主物理内存获取5之后，在自己的线程工作内存去操作，t1把自己工作内存中的5改成2019,在同步到主物理内存的时候，会先看此时主物理内存的值是不是5，如果是5，就改成2019，当然，之前t2线程，也把5取到自己的工作内存，改成2018，但是现在，t1已经把主物理内存的值修改了，此时t2，同步回主物理内存的时候，发现主物理内存的值已经不是5了，而是2019，所以会false，不能发生交换。这就是所谓的比较和交换。比较是真实值和期望值的比较。值相同就可以交换，不同不能交换。

2、CAS工作原理和UnSafe 的理解？

或者说为什么用CAS不用synchronized呢？

getAndIncrement();

/**
 * Atomically increments by one the current value.
 *
 * @return the previous value
 */
public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

那么什么是Unsafe 类呢？

UnSafe 类

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            // 获取下面 value 的地址偏移量
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;
    // ...
}

• Unsafe 是 CAS 的核心类，由于 Java 方法无法直接访问底层系统，而需要通过本地（native）方法来访问， Unsafe 类相当一个后门，基于该类可以直接操作特定内存的数据。Unsafe 类存在于 sun.misc 包中，其内部方法操作可以像 C 指针一样直接操作内存，因为 Java 中 CAS 操作执行依赖于 Unsafe 类。
• 变量 vauleOffset，表示该变量值在内存中的偏移量，因为 Unsafe 就是根据内存偏移量来获取数据的。
• 变量 value 用 volatile 修饰，保证了多线程之间的内存可见性。

在看看CAS

• CAS 的全称 Compare-And-Swap，它是一条 CPU 并发。
• 它的功能是判断内存某一个位置的值是否为预期，如果是则更改这个值，这个过程就是原子的。
• CAS 并发原体现在 JAVA 语言中就是 sun.misc.Unsafe 类中的各个方法。调用 UnSafe 类中的 CAS 方法，JVM 会帮我们实现出 CAS 汇编指令。这是一种完全依赖硬件的功能，通过它实现了原子操作。由于 CAS 是一种系统源语，源语属于操作系统用语范畴，是由若干条指令组成，用于完成某一个功能的过程，并且原语的执行必须是连续的，在执行的过程中不允许被中断，也就是说 CAS 是一条原子指令，不会造成所谓的数据不一致的问题。

那么继续看看getAndAddInt()方法

// unsafe.getAndAddInt
public final int getAndAddInt(Object obj, long valueOffset, long expected, int val) {
    int temp;
    do {
        temp = this.getIntVolatile(obj, valueOffset);  // 获取快照值
    } while (!this.compareAndSwap(obj, valueOffset, temp, temp + val));  // 如果此时 temp 没有被修改，就能退出循环，否则重新获取
    return temp;
}

总结一下CAS

如图

CAS的应用

CAS有三个操作数，内存值V，旧的预测值A，要修改的更新值B。

当且仅当预期值A和内存值v相同时，将内存值V修改为B，否则什么都不做，自己自旋锁。

CAS的底层汇编

CAS的缺点？

1、循环时间长，开销时间大

如果CAS失败，那么就会一直尝试，如果CAS一直不成功，会一直执行do while，死循环，可能会给CPU带来很大的开销。

2、只能保证一个共享变量的原子性。

对于多个共享变量的操作，循环CAS就无法保证操作的原子性，这个时候就可以用锁来保证原子性。

3、引出 ABA 问题

**这是CAS最大的缺点**，那么ABA问题的描述是什么呢？如下图

那么ABA问题怎么产生的呢？
如上图，

继续ABA问题

对于一个普通的原子引用

package threadDemo.casDemo;


import java.util.concurrent.atomic.AtomicReference;

class User{
    String name ;
    int age;
    public User(String name,int age){
        this.age = age;
        this.name = name;
    }
}

public class AtomicReferenceDemo {
    public static void main(String[] args) {
        User cuzz = new User("cuzz", 18);
        User faker = new User("faker", 20);
        AtomicReference<User> atomicReference = new AtomicReference<>();
        atomicReference.set(cuzz);
        System.out.println(atomicReference.compareAndSet(cuzz, faker)); // true
        System.out.println(atomicReference.get()); // User(userName=faker, age=20)
    }
}

对于ABA问题的解决，先通过一个程序看看ABA的产生

import java.util.concurrent.atomic.AtomicReference;

public class ABADemo {
    private static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);

    public static void main(String[] args) {
        new Thread(() -> {
            atomicReference.compareAndSet(100, 101);
            atomicReference.compareAndSet(101, 100);
        }).start();

        new Thread(() -> {
            // 保证上面线程先执行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicReference.compareAndSet(100, 2019);
            System.out.println(atomicReference.get()); // 2019
        }).start();
    }
}

当有一个值从 A（100） 改为 B（101） 又改为 A（100），这就是 ABA 问题。

ABA问题的结局

加版本号，和值一样，有一个期望版本号和实际版本号，具体实现如下

时间戳原子引用

import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

public class ABADemo2 {
    private static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);

    public static void main(String[] args) {
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + " 的版本号为：" + stamp);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1 );
            atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1 );
        }).start();

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + " 的版本号为：" + stamp);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean b = atomicStampedReference.compareAndSet(100, 2019, stamp, stamp + 1);
            System.out.println(b); // false
            System.out.println(atomicStampedReference.getReference()); // 100
        }).start();
    }
}

先保证两个线程的初始版本为一致，后面修改是由于版本不一样就会修改失败。这样就可以避免ABA问题。