CAS详解

1.CAS

学习技术的方法论
它是什么？它能干什么？它为什么出现？它解决了哪些痛点？没有它之前我们是怎么做的？有了它之后我们有哪些便捷？方便的方法和API可以更好地帮助我们解决问题。

1.1 什么是CAS?

CAS(compare and swap)的缩写，中文翻译成比较并交换,实现并发算法时常用到的一种技术。
它包含三个操作数——内存位置、预期原值及更新值。
执行CAS操作的时候，将内存位置的值与预期原值比较:如果相匹配，那么处理器会自动将该位置值更新为新值，
如果不匹配，处理器不做任何操作，多个线程同时执行CAS操作只有一个会成功。

1.2 CAS原理

CAS有3个操作数，位置内存值V，旧的预期值A，要修改的更新值B。当且仅当旧的预期值A和内存值V相同时，将
内存值V修改为B，否则什么都不做或重试。它重试的这种行为称为自旋! 原理有点类似乐观锁，修改带版本号。

CAS是JDK提供的非阻塞原子性操作，它通过硬件保证了比较-更新的原子性。
它是非阻塞的且自身具有原子性，也就是说这玩意效率更高且通过硬件保证，说明它更可靠。

CAS是一条CPU的原子指令(cmpxchg指令），不会造成所谓的数据不一致问题，Unsafe提供的CAS方法（如compareAndSwapXXX）底层实现即为CPU指令cmpxchgo

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

原子类靠的是CAS思想，CAS思想实现靠的是Unsafe类。工作中尽量不要使用UnSafe类，使用不当容易出现大问题。
以原子类AtomicIntefer为例

Unsafe类是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地(native)方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。
注意Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。

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

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

我们知道i++线程不安全的，那atomicInteger.getAndIncrement()

CAS的全称为Compare-And-Swap，它是一条CPU并发原语。
它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。
Atoniclnteger类主要利用CAS(compare and swap) + volatile和 native方法来保证原子操作，从而避免 synchronized的高开销，执行效率大为提升。
AtomicInteger的getAndIncrement()

    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
1
2
3

Unsafe的getAndAddInt()

    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }
1
2
3
4
5
6
7
8

此处复习一下do while循环，因为工作中不太常用
do {
循环体语句；
} while（条件判断语句）；

执行流程：
执行循环体语句
执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，回到循环体语句继续循环。

do while 循环第一次会不经过判断直接执行一次循环体，这与for循环和while循环都不相同。

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

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

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

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

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

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

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

你只需要记住:CAS是靠硬件实现的从而在硬件层面提升效率，最底层还是交给硬件来保证原子性和可见性实现方式是基于硬件平台的汇编指令，在intel的CPU中(X86机器上)，使用的是汇编指令cmpxchg指令。
核心思想就是:比较要更新变量的值V和预期值E(compare)，相等才会将V的值设为新值N(swap）如果不相等自旋再来。

1.3 原子更新引用类

原子更新基本类型的AtomicInteger,只能更新一个变量，如果要原子更新多个变量，就要使用这个原子更新引用类型提供的类。

public class AtomicReferenceTest {
    public static void main(String[] args) {
        Cat cat1 = new Cat("狸花",1);
        Cat cat2 = new Cat("奶牛",2);
        Cat cat3 = new Cat("大橘",3);
        AtomicReference<Cat> reference = new AtomicReference<>(cat1);
        new Thread(()->{
            System.out.println(reference.compareAndSet(cat1,cat2)+":"+reference.get());
        }).start();
        new Thread(()->{
            System.out.println(reference.compareAndSet(cat1,cat3)+":"+reference.get());
        }).start();
    }
}
class Cat{
    private String color;
    private  int age;

    public Cat(String color, int age) {
        this.color = color;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "color='" + color + '\'' +
                ", age=" + age +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

1.4 CAS与自旋锁

自旋锁(spinlock)，借鉴CAS思想
CAS是实现自旋锁的基础，CAS利用CPU指令保证了操作的原子性，以达到锁的效果，至于自旋呢，看字面意思也很明白，自己旋转。是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，当线程发现锁被占用时，会不断循环判断锁的状态，直到获取。这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU

CAS是实现自旋锁的基础，自旋翻译成人话就是循环，一般是用一个无限循环实现。这样一来，一个无限循环中，执行一个CAS操作，当操作成功返回 true 时，循环结束;当返回 false 时，接着执行循环，继续尝试CAS操作，直到返回true。

自旋锁代码

public class SpinLockTest {
    AtomicReference<Thread> reference = new AtomicReference<>();

    public static void main(String[] args) {
        SpinLockTest spinLockTest = new SpinLockTest();
        new Thread(() -> {
            spinLockTest.lock();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockTest.unLock();
        }, "A").start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            System.out.println("B进入时间" + System.currentTimeMillis());
            spinLockTest.lock();
            System.out.println("B拿到锁时间" + System.currentTimeMillis());
            spinLockTest.unLock();
        }, "B").start();
    }

    private void lock() {
        Thread thread = Thread.currentThread();
        while (!(reference.compareAndSet(null, thread))) {
        };
        System.out.println("当前持有锁的线程：" + thread.getName());
    }

    private void unLock() {
        Thread thread = Thread.currentThread();
        while (!(reference.compareAndSet(thread, null))) {
        };
        System.out.println("当前释放锁的线程：" + thread.getName());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

1.5 ABA问题

CAS缺点
循环时间长开销很大。
引出来ABA问题

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

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

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

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

一句话解决ABA:比较+版本号

版本号时间戳原子引用AtomicStampedReference

ABA问题解决代码

public class AtomicStampedReferenceTest {
    public static void main(String[] args) {
        Cat cat1 = new Cat("狸花",1);
        Cat cat2 = new Cat("奶牛",2);
        Cat cat3 = new Cat("大橘",3);
        AtomicStampedReference<Cat> reference = new AtomicStampedReference<>(cat1,1);
        new Thread(()->{
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程A修改结果"+reference.compareAndSet(cat1, cat2, reference.getStamp(), reference.getStamp()+1)+",stamp:"+reference.getStamp());
            reference.compareAndSet(cat2,cat1,reference.getStamp(),reference.getStamp()+1);
        },"A").start();

        new Thread(()->{
            int stamp = reference.getStamp();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程B修改结果"+reference.compareAndSet(cat1, cat3, stamp, stamp + 1)+",stamp:"+reference.getStamp());
        },"B").start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

每次操作后版本号每次必须改变，要么递增，要么递减，需要保持一致，不能有的线程增有的线程减。

注：本文是学习B站周阳老师《尚硅谷2022版JUC并发编程》课程所做学习笔记。