第八章：CAS

原子类

在 java.util.concurrent.atomic 包下提供了一些原子类

原子是不可分割的最小单位，故原子类可以认为其操作都是不可分割 。】

对多线程访问同一个变量，我们需要加锁，而锁是比较消耗性能的，JDk1.5之后， 新增的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式， 就是原子类, 原子类就采用了乐观锁的CAS方式实现的

没有 CAS 之前

在没有 CAS 之前，经常使用 synchronized 锁保证线程的安全性，但是众所周期 synchronized 锁比较中，需要操作系统实现，效率并不高

public class T3
{
    volatile int number = 0;
    //读取
    public int getNumber()
    {
        return number;
    }
    //写入加锁保证原子性
    public synchronized void setNumber()
    {
        number++;
    }
}

使用 CAS 之后

使用 原子类确保线程的安全性，CAS 就类似于乐观锁

public class T3
{
    volatile int number = 0;
    //读取
    public int getNumber()
    {
        return number;
    }
    //写入加锁保证原子性
    public synchronized void setNumber()
    {
        number++;
    }
    //=================================
    //下面是新版本
    //=================================
    AtomicInteger atomicInteger = new AtomicInteger();

    public int getAtomicInteger()
    {
        return atomicInteger.get();
    }

    public void setAtomicInteger()
    {
        atomicInteger.getAndIncrement();//先读再加
    }
}

CAS 是什么

compare and swap的缩写，中文翻译成 比较并交换,实现并发算法时常用到的一种技术。它包含三个操作数——内存位置、预期原值及更新值。

1. 变量内存地址，V表示

2. 旧的预期值，A表示

3. 准备设置的新值，B表示

CAS 原理

当执行CAS指令时，只有当V等于A时，才会用B去更新V的值，否则就不会执行更新操作或重来。

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

举例说明

假设有俩个线程A、B 对主内存中的变量 i 进行自增操作：

此时如果 线程A 获取主内存中的值加载到 工作内存，CAS 就像是乐观锁，在线程A操作过程中认为只有它一个线程正在进行操作。

但事实并没有那么乐观，正好线程B也将 值加载到工作内存中，并且先于 线程A 完成了修改的操作，此时线程B拿着旧的预期值 5 和 变量内存地址（此时 i =5）作比较，发现一样，就用新值 替换掉了 旧的内存地址，先于线程A完成了更新。

而此时线程A计算完，拿着旧的预期值 5 和 新的的内存地址 进行比较，发现不一样，此时就会放弃更新，或者在重新来一次。重新获取主内存的值 加载到工作内存，然后进行 自增 操作。

CASDemo

简单 API 的使用：

public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        // 第一个参数: 期望值  第二个参数: 修改的新值
        // 修改成功 返回 false
        System.out.println(atomicInteger.compareAndSet(5, 2022) + "\t" + atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(5, 2023) + "\t" + atomicInteger.get());

    }
}

结果：

true	2022
false	2022

硬件保证 CAS 的原子性

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

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

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

compareAndSet 源码分析

底层调用了 UnSafe 类的 compareAndSwapInt

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

compareAndSwapInt 为 本地方法。

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

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

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

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

我们可以看见原子类中的方法都是调用的 UnSafe 中的方法，那么 UnSafe 类到底是什么呢？

UnSafe 的理解

CAS 是一种理念，而它的落地实现就是 UnSafe 类 , 可以说它是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（native）方法来访问，Unsafe相当于一个后门 ，基于该类可以直接操作特定内存的数据 。Unsafe类存在于 rt.jar 包中的 sun.misc 包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。

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

i++ 与 getAndIncrement()

我们都知道 i++ 是非原子性操作，存在线程不安全性。

原子类中 也提供了一个 自增+1 的方法，该方法保证了原子性操作。

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

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

该方法调用了 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;
    }
// 通过调用本地 getIntVolatile 获取 最新值
public native int getIntVolatile(Object var1, long var2);

代码中使用了 do while 循环，这个就体现了 CAS 的自旋 思想。根据 当前对象和当前对象的偏移地址 获得 主内存 中的最新值，通过 compareAndSwapInt 方法，进行比较，如果 偏移地址 var2 和 预期值 var5 相等，就进行+1操作，如果不相等就循环再次尝试。

总结

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

compareAndSwapInt 底层原理

从上面的源码分析中， 进行比较并交换 时，调用的是本地的方法。

那么在本地方法中，是如何执行的，如何实现的呢？

• Unsafe类中的compareAndSwapInt，是一个本地方法，该方法的实现位于unsafe.cpp中

 UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv* env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
      UnsafeWrapper("Unsafe_CompareAndSwapInt");
      oop p = JNIHandles::resolve(obj);
    // 先想办法拿到变量value在内存中的地址，根据偏移量valueOffset，计算 value 的地址
      jint* addr = (jint* ) index_oop_from_field_offset_long(p, offset);
    // 调用 Atomic 中的函数 cmpxchg来进行比较交换，其中参数x是要交换的值，e是要比较的值
    //cas成功，返回期望值e，等于e，此方法返回true;
    //cas失败，返回内存中的value值，不等于e，此方法返回false
      return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
    UNSAFE_END
    //-------------核心(Atomic::cmpxchg(x, addr, e)) == e;
    //JDK提供的CAS机制，在汇编层级会禁止变量两侧的指令优化，然后使用cmpxchg指令比较并更新变量值（原子性）

再看看 cmpxchg 是什么：

    unsigned Atomic::cmpxchg(unsigned int exchange_value,volatile unsigned int* dest, unsigned int compare_value) {
        assert(sizeof(unsigned int) == sizeof(jint), "more work to do");
 //根据操作系统类型调用不同平台下的重载函数，这个在预编译期间编译器会决定调用哪个平台下的重载函数
        return (unsigned int)Atomic::cmpxchg((jint)exchange_value, (volatile jint*)dest, (jint)compare_value);
    }

• 不同的操作系统下会调用不同的compxchg重载函数，例如win10

inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
  //判断是否是多核CPU
  int mp = os::is_MP();
  __asm {
    //三个move指令表示的是将后面的值移动到前面的寄存器上
    mov edx, dest
    mov ecx, exchange_value
    mov eax, compare_value
    //CPU原语级别，CPU触发
    LOCK_IF_MP(mp)
    //比较并交换指令
    //cmpxchg: 即“比较并交换”指令
    //dword: 全称是 double word 表示两个字，一共四个字节
    //ptr: 全称是 pointer，与前面的 dword 连起来使用，表明访问的内存单元是一个双字单元 
    //将 eax 寄存器中的值（compare_value）与 [edx] 双字内存单元中的值进行对比，
    //如果相同，则将 ecx 寄存器中的值（exchange_value）存入 [edx] 内存单元中
    cmpxchg dword ptr [edx], ecx
  }
}

总结

• CAS是靠硬件实现的从而在硬件层面提升效率，最底层还是交给硬件来保证原子性和可见性
• 实现方式是基于硬件平台的汇编指令，在intel的CPU中(X86机器上)，使用的是汇编指令cmpxchg指令。

核心思想就是：比较要更新变量的值 V 和预期值A（compare），相等才会将V的值设为新值B（swap）如果不相等自旋再来。

自定义原子类型

原子类有原子整型，原子布尔型…那么可不可以使用我们自定义的类型。

是可以的，在 jdk 中提供了 AtomicReference 类，该类可以指向我们自定义的类型

代码示例：

public class AtomicReferenceTest {
    public static void main(String[] args) {
        AtomicReference<User> atomicReference = new AtomicReference<>();

        User z3 = new User("zhangsan",2);
        User li4 = new User("李四",3);

        atomicReference.set(z3);
        // 比较并交换
        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class  User {
    private String name;
    private int age ;
}

输出结果：

true	User(name=李四, age=3)

自旋锁（spinlock）

自旋锁采用 CAS 思想，避开了 synchronized 这种重量级锁，靠硬件实现的一种轻量级锁。

是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，当线程发现锁被占用时，会不断循环判断锁的状态，直到获取。这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

手写自旋锁

A线程先进来调用 lock 方法自己持有锁5秒钟，B随后进来后发现 当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到。

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

代码：

public class SpinlockDemo {
    AtomicReference<Thread> reference = new AtomicReference<>();
    // 上锁
    public void lock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + " lock...");

        while (!reference.compareAndSet(null, thread)) {

        }
    }

    // 解锁
    public void unLock() {
        Thread thread = Thread.currentThread();
        reference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName() + " unLock...");
    }
    public static void main(String[] args) {
        SpinlockDemo spinlockDemo = new SpinlockDemo();
        new Thread(() -> {
            spinlockDemo.lock();
            try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}
            spinlockDemo.unLock();
        }, "A").start();

        try {Thread.sleep(300);} catch (InterruptedException e) {e.printStackTrace();}

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

结果：

A lock...
B lock...
A unLock...
B unLock...

执行步骤：

• 线程A先执行 lock 方法，通过 compareAndSet 判断变量内存地址和旧的预期值相等，因此进行修改，修改为新值 thread。修改完后 执行 sleep ，沉睡了 5s…
• 此时 线程B 开始执行 lock，通过 compareAndSet 判断变量内存地址和旧的预期值并不相等，因此一直 在 while 循环中 尝试…
• 线程 A 经过 5s 醒来，执行 unLock，将变量修改为了 null
• 由于 线程A 修改了变量为null，线程 B 在while 循环中通过判断 为true，结束循环，并执行 unlock 方法。

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

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

解决 ABA 问题

jdk 中提供了一个类：AtomicStampedReference , 线程每一次对内存中的变量进行操作时都会印上一个版本戳。通过这个版本戳来判断内存中的值是否被修改过。

AtomicStampedReference 的使用

AtomicStampedReference 构造器方法

Constructor and Description
AtomicStampedReference(V initialRef, int initialStamp) 创建一个新的 AtomicStampedReference与给定的初始值。

相关的API

boolean	compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp) 如果当前引用 等于 预期值并且 当前版本戳等于预期版本戳, 将更新新的引用和新的版本戳到内存
V	get(int[] stampHolder) 返回引用和版本戳的当前值。
V	getReference() 返回引用的当前值。
int	getStamp() 返回当前的版本戳

代码演示：

public class AtomicStampReferenceTest {
    public static void main(String[] args) {
        Book java = new Book(1, "Java");
        // 设置初始引用 和 初始版本号
        AtomicStampedReference<Book> stampedReference = new AtomicStampedReference<Book>(java,1);
        // 获取当前引用和版本戳
        System.out.println(stampedReference.getReference() + "\t" + stampedReference.getStamp());

        Book mysql = new Book(2, "mysql");
        // 第一次 进行比较并交换
        boolean result = stampedReference.compareAndSet(java, mysql, stampedReference.getStamp(), stampedReference.getStamp() + 1);
        System.out.println(result + "\t" + stampedReference.getReference() + "\t" + stampedReference.getStamp());

        // 第二次进行比较并交换
        boolean result1 = stampedReference.compareAndSet(mysql, java, stampedReference.getStamp(), stampedReference.getStamp() + 1);
        System.out.println(result + "\t" + stampedReference.getReference() + "\t" + stampedReference.getStamp());

    }
}
@Data
@NoArgsConstructor
@AllArgsConstructor
class Book {
    private int bookId;
    private String bookName;
}

输出结果：

Book(bookId=1, bookName=Java)	1
true	Book(bookId=2, bookName=mysql)	2
true	Book(bookId=1, bookName=Java)	3

AtomicStampedReference 解决ABA问题

未使用 AtomicStampedReference 多线程下的 ABA 问题：

虽然修改成功了，但是在线程A中已经将 值修改过了。这就可能会造成安全问题。

public class ABADemo {
    static AtomicInteger atomicInteger = new AtomicInteger(100);

    public static void main(String[] args) {
        new Thread(() -> {
            atomicInteger.compareAndSet(100,101);
            try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}
            atomicInteger.compareAndSet(101,100);
        }, "A").start();
        // 保证 线程A 先执行
        try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}
        new Thread(() -> {
            boolean result = atomicInteger.compareAndSet(100, 101);
            // 获取值
            System.out.println(result + "\t" + atomicInteger.get());
        }, "B").start();

    }
}

输出结果：

true	101

使用 AtomicStampedReference 解决多线程下的 ABA 问题：

public class ABADemo {
    static AtomicStampedReference<Integer> atomicStampReference = new AtomicStampedReference<Integer>(100, 1);

    public static void main(String[] args) {
        new Thread(() -> {
            int stamp = atomicStampReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "首次版本戳: " + stamp);
            // 为了线程B 获取相同的版本戳
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 第一次进行比较交换
            boolean result1 = atomicStampReference.compareAndSet(100, 101,
                    atomicStampReference.getStamp(),
                    atomicStampReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName()+ "\t" + result1 + "\t" + atomicStampReference.getReference() + "\t" + atomicStampReference.getStamp());

            // 第二次交换
            boolean result2 = atomicStampReference.compareAndSet(101, 100,
                    atomicStampReference.getStamp(),
                    atomicStampReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName()+ "\t" + result2 + "\t" + atomicStampReference.getReference() + "\t" + atomicStampReference.getStamp());

        }, "线程A").start();

        new Thread(() -> {
            int stamp = atomicStampReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "首次版本戳: " + stamp);
            try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}
            // 第三次交换
            boolean result3= atomicStampReference.compareAndSet(100, 101, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + "\t"  + result3 + "\t" + atomicStampReference.getReference() + "\t" + atomicStampReference.getStamp());

        }, "线程A").start();
    }
}

输出结果：

线程A	首次版本戳: 1
线程A	首次版本戳: 1
线程A	true	101	2
线程A	true	100	3
线程A	false	100	3

---

---

各位彭于晏，如有收获点个赞不过分吧…✌✌✌

---