【JUC】6.CAS

1. 什么是CAS

CAS是compare and swap的缩写，中文翻译成比较并交换，实现并发算法时常用的一种技术

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

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

如果相匹配，那么处理器会自动将该位置值更新为新值

如果不匹配，处理器不做任何操作，多线程同时执行CAS操作只有一个会成功

位置内存值V，旧的预期值A，要修改的更新值B

当且仅当旧的预期值A与内存值V相同时，将内存V修改为B，否则什么都不做或者重来

当它重来重试的这种行为称为——自旋

---

2. CAS的一个小demo

public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        System.out.println(atomicInteger.compareAndSet(5, 2020) + "\t" + atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(5, 2022) + "\t" + atomicInteger.get());
    }
}

java.util.concurrent.atomic.AtomicInteger.compareAndSet()是Java中的一种内置方法

如果当前值等于参数给定的期望值，则将值设置为参数中的传递值。

该函数返回一个布尔值，该布尔值表示更新是否完成。

• 在第一次的时候，期望值为5，更新后的值为2020，由于atomicInteger一开始的值为5，那么这个更新操作是true，再次获取应该是更新之后的值2020
• 而第二次，期待值是5，但是在第一次的时候值已经被更新为2020，所以为false，这个更新操作失败，获取到的值应该是更新之前的第一次更新的2020

---

3. CAS硬件级别保证

CAS是JDK提供的非阻塞原子性操作，它是通过硬件比较-更新的原子性

它是非阻塞的且自身具有原子性，也就是说这玩意效率更高且通过硬件保证，说明这玩意更可靠

compareAndSet里面是unsafe调用compareAndSwapInt方法，而compareAndSwapInt则是native修饰，说明是一个底层方法，需要在openjdk源码中才能查看

public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

• var1：表示需要操作的对象
• var2：表示要操作的对象中的属性地址的偏移量
• var4：表示需要修改数据的期望的值
• var5/var6：表示需要修改为的值

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

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

---

4. 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();
    //表示该变量值得偏移地址，因为Unsafe就是根据内存便宜地址获取数据的
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    //变量value用volatile修饰，保证了多线程之间的内存可见性
    private volatile int value;
}

在AtomicInteger是通过Unsafe.getUnsafe()获取unsafe的

那么Unsafe到底是什么呢？

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

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

Unsafe类底层实现自旋锁

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;
}

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

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

2线程A通过getintVolatile(var1var2)拿到value值3，这时线程A被挂起。

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

---

5. AtomicReference

一个对象的引用，可以自动更新。看到的原子变量性质的描述 java.util.concurrent.atomic包装规范。

该对象可以封装任何对象作为原子引用

public class AtomicReferenceDemo {

    @Data
    @AllArgsConstructor
    static
    class User{
        private String name;
        private Integer age;
    }

    public static void main(String[] args) {
        User user1 = new User("张三", 18);
        User user2 = new User("李四", 20);
        User user3 = new User("老王", 21);
        AtomicReference<User> reference = new AtomicReference<User>();
        reference.set(user1);
        System.out.println(reference.compareAndSet(user1, user2) + "\t" + reference.get());
        System.out.println(reference.compareAndSet(user1, user3) + "\t" + reference.get());
    }
}

---

6. 手撕自旋锁

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

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

自旋锁的好处是循环比较没有类似wait的阻塞

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" + "----task over, unLock----");

    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(() -> {
            spinLockDemo.lock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            spinLockDemo.unLock();
        }, "A").start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            spinLockDemo.lock();
            spinLockDemo.unLock();
        }, "B").start();
    }
}

一开始A先启动，B后启动，atomicReference被设置为A线程的thread的实例对象

B调用lock方法的时候，期望值为null，但是一开始这个被A占了,于是B就一直在循环等待A调用unLock方法

接下来等到A执行unLock方法，然后就B就可以抢占资源

---

7. CAS的缺点

在getAndAddInt方法执行时候，有个do while方法，如果CAS失败，会一直尝试。如果CAS长时间一直不成功，可能会给CPU带来很大的开销

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;
}

并且还会出现ABA问题

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

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

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

于是就会有了AtomicStampedReference的出现

AtomicStampedReference比较的版本号，即使值一样版本号不一样也会修改失败

@Data
@AllArgsConstructor
static
class User{
    private String name;
    private Integer age;
}

public static void main(String[] args) {
    User user1 = new User("张三", 18);
    User user2 = new User("李四", 20);
    User user3 = new User("老王", 21);
    AtomicStampedReference<User> reference = new AtomicStampedReference<User>(user1, 1);
    System.out.println(reference.compareAndSet(user1, user2, reference.getStamp(), reference.getStamp() + 1));
    System.out.println(reference.compareAndSet(user2, user1, reference.getStamp(), reference.getStamp() + 1));
    System.out.println(reference.compareAndSet(user1, user3, 1, reference.getStamp() + 1));

}

---