CAS 介绍

WHAT CAS

CAS即compare and swap，包含三个操作数：

内存位置
预期原值
更新值

执行CAS操作时，将内存位置与预期原值进行比较，如果匹配，那么处理器会自动将该位置值更新为新值；如果不匹配，那么处理器不做任何操作，多个线程同时执行CAS操作只有一个会成功。

WHY CAS

CAS有3个操作数，位置内存值V、旧的预期值A和要修改的更新值B。

当且仅当旧的预期值A和内存值V相同时，将内存值V修改为B，否则无操作或者重试，这种重试行为称为自旋。

硬件级别

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

CAS是一条CPU的原子指令cmpxchg指令，不会造成数据不一致问题，Unsafe提供的CAS方法（如compareAndSwapXXX）底层实现即为CPU指令cmpxchg。
执行cmpxchg指令时会判断当前系统是否为多核系统，如果是就给总线加锁，只有一个线程会对总线加锁成功，加锁成功之后会执行CAS操作，CAS的原子性实际上是CPU实现独占的

compareAndSet(int expect, int update) 源码分析

CAS 源码分析

UnSafe 源码分析

谈谈你对UnSafe的理解？

UnSafe

UnSafe是CAS核心类，由于Java方法无法直接访问底层，需要通过本地（native）方法访问，基于UnSafe可以直接操作特定内存的数据

UnSafe类存在于sun.misc，其内部方法可以直接操作内存，CAS操作依赖于UnSafe类方法

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

valueOffset

变量valueOffset表示在内存中的偏移地址

value

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

AtomicInteger 源码分析

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

CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用UnSafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。

再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

getAndIncrement() 源码分析

以下操作会发生什么？

1	new AtomicInteger().getAndIncrement();

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

AtomicInteger里面的value原始值为3，即主内存中Atomiclnteger的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收工
此时线程A恢复，执行compareAndSwapInt方法比较，发现自己手上的值3和主内存的值4不一致，说明该值已经被其他线程抢先一步修改，那线程A本次修改只能重新读取，重来一遍了
线程A重新获取value值，由于变量value被volatile修饰（其他线程对它的修改，线程A总是能看到），线程A继续执行compareAndSwapInt进行比较替换，直到成功

汇编角度分析底层原理

native修饰的方法代表底层方法

cmpxchg

win10下cmpxchg重载函数

总结

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

原子引用

class User {
    String name;
    int age;
}
public class AtomicReferenceDemo {

    public static void main(String[] args) {

        AtomicReference<User> reference = new AtomicReference<User>();

        User z3 = new User("z3", 22);
        User li4 = new User("li4", 28);

        reference.set(z3);

        // true	User(name=li4, age=28)
        System.out.println(reference.compareAndSet(z3, li4) + "\t" + reference.get().toString());

        // false	User(name=li4, age=28)
        System.out.println(reference.compareAndSet(z3, li4) + "\t" + reference.get().toString());
    }
}

CAS 与自旋锁

自旋锁（spinlock）

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

使用CAS操作手写自旋锁

线程A进来先调用myLock()持锁五秒，线程B随后进来发现线程A持锁，只能通过自旋等待，直到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, preparing lock");
        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, complete 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();

        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            spinLockDemo.lock();

            spinLockDemo.unlock();
        }, "B").start();
    }
}

A	*****come in, preparing lock
B	*****come in, preparing lock
A	*****task over, complete unlock
B	*****task over, complete unlock