JUC并发编程-CAS

CAS

什么是CAS

简介

Compare And Set（或Compare And Swap），CAS是解决多线程并行情况下使用锁造成性能损耗的一种机制，采用这种无锁的原子操作可以实现线程安全，避免加锁的笨重性。

操作

CAS操作包含三个操作数：**内存位置（V）、预期原值（A）、新值(B)。**如果内存位置的值与预期原值相等，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。(简单解释：CAS操作需要输入两个数值，一个旧值(期望操作前的值)和一个新值，在操作期间先比较下在旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。)

应用背景

• java提供的CAS原子操作类AtomicInteger等，核心就是CAS，因为CAS操作是原子性的，所以多线程并发使用CAS更新数据时，可以不使用锁，提高了并发性能。JDK中大量使用了CAS来更新数据而防止加锁(synchronized 重量级锁)来保持原子更新。

• CAS是实现自旋锁的基础，CAS 利用 CPU 指令保证了操作的原子性，以达到锁的效果，循环这个指令，直到成功为止。

• CAS的全称为Compare-And-Swap，直译就是对比交换。是一条CPU的并发原语，其实现方式是基于硬件平台的汇编指令，就是说CAS是靠硬件实现的，JVM只是封装了汇编调用，那些AtomicInteger类便是使用了这些封装后的接口

CAS使用示例

如果不使用CAS，在高并发下，多线程同时修改一个变量的值我们需要synchronized加锁(可能有人说可以用Lock加锁，Lock底层的AQS也是基于CAS进行获取锁的)。

public class Test {

    public static void main(String[] args) {

        MyData myData = new MyData();

        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    myData.numAdd();
                    myData.addAtomic();
                }
            }).start();
        }

        while(Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println("i++操作不保证原子性"+myData.number);
        System.out.println("CAS操作保证原子性"+myData.atomicInteger);

    }
}

class MyData{
    volatile int number=0;

    public void numAdd(){
        number++;
    }

    AtomicInteger atomicInteger=new AtomicInteger();

    public void addAtomic(){
        //初始值是0
        atomicInteger.getAndIncrement();
    }
}

结果

i++操作不保证原子性17206
CAS操作保证原子性20000

CAS 问题

CAS 方式为乐观锁，synchronized 为悲观锁。因此使用 CAS 解决并发问题通常情况下性能更优。

但使用 CAS 方式也会有几个问题：

ABA问题

因为CAS需要在操作值的时候，检查值有没有发生变化，比如没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时则会发现它的值没有发生变化，但是实际上却变化了。

import java.util.concurrent.atomic.AtomicReference;

public class TestAtomicStampedReference {

   static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);

    public static void main(String[] args) {
        //模拟ABA
        System.out.println("====模拟ABA问题产生===");
        new Thread(()->{
            atomicReference.compareAndSet(100,101);
            atomicReference.compareAndSet(101,100);
        },"线程1").start();

        new Thread(()->{
            //线程睡眠1秒 确保上面的线程先完成
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100, 1026));


        },"线程2").start();
    }
}
====模拟ABA问题产生===
true

• 线程2想要将100通过CAS改成1026，所以线程2的预期值为100，更新值为1026
• 但是在这之前线程1先将100改成101，然后又将101改回100
• 对于线程2，通过CAS检查值发现没有变化，将100改为1026，返回true，这就是ABA问题的产生

源码解析

这里为AtomicReference的源码

public final boolean compareAndSet(V expect, V update) {
    
        //1.this表示调用此方法的实例对象，应该是用于native方法计算实例对象的地址
        //2.为当前对象字段的偏移量(哪来的？下面会看到)   加上当前实例对象的地址 就能找到值所在物理地址  
        //3.对应地址的值的期望值
        //4.如果期望值和实际值相等，将要修改的新值
        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
    }

//原来在静态代码块里
static {
        try {
            //初始化时就计算AtomicReference存储字段的偏移量
            valueOffset = unsafe.objectFieldOffset
                (AtomicReference.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    

解决ABA

ABA问题的解决思路就是增加版本号

从Java 1.5开始，JDK的Atomic包里提供了一个类AtomicStampedReference来解决ABA问题==。这个类的compareAndSet方法的作用是首先检查当前值是否等于预期值，并且检查当前版本号是否等于预期版本号如果全部相等，==则以原子方式将值和版本号设置为给定的更新值。

import java.util.concurrent.atomic.AtomicStampedReference;

public class TestAtomicStampedReference {


   static  AtomicStampedReference<Integer> atomicStampedReference=new AtomicStampedReference(100,0);

    public static void main(String[] args) {
       

        //增加版本号
        new Thread(()->{
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {

            }
            System.out.println("===利用版本号解决ABA问题===");

            System.out.println("初始版本号："+atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(100,101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("第1次修改版本号："+atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("第2次修改版本号："+atomicStampedReference.getStamp());


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


        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("初始版本号: "+stamp);

            System.out.println("当前版本号: "+atomicStampedReference.getStamp());
            boolean result = atomicStampedReference.compareAndSet(100, 1026, stamp, stamp + 1);
            System.out.println("修改"+result+"  值为 "+atomicStampedReference.getReference());
        },"线程4").start();
    }
}

===利用版本号解决ABA问题===
初始版本号：0
第1次修改版本号：1
第2次修改版本号：2
初始版本号: 0
当前版本号: 2
修改false  值为 100

循环时间长开销大

自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。

如果JVM能支持处理器提供的pause指令，那么效率会有一定的提升。pause指令有两个作用：第一，它可以延迟流水线执行命令(de-pipeline)，使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零；第二，它可以避免在退出循环的时候因内存顺序冲突(Memory Order Violation)而引起CPU流水线被清空(CPU Pipeline Flush)，从而提高CPU的执行效率。

只能保证一个共享变量的原子操作

当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。

从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作。

UnSafe类详解

上文我们了解到Java原子类是通过UnSafe类实现的，这节主要分析下UnSafe类。UnSafe类在J.U.C中CAS操作有很广泛的应用。

• Unsafe是位于sun.misc包下的一个类，是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地(native)方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。其内部操作可以像C语言的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法
• 但由于Unsafe类使Java语言拥有了类似C语言指针一样操作内存空间的能力，这无疑也增加了程序发生相关指针问题的风险。在程序中过度、不正确使用Unsafe类会使得程序出错的概率变大，使得Java这种安全的语言变得不再“安全”，因此对Unsafe的使用一定要慎重。

先来看下这张图，对UnSafe类总体功能：

如上图所示，Unsafe提供的API大致可分为内存操作、CAS、Class相关、对象操作、线程调度、系统信息获取、内存屏障、数组操作等几类，下面将对其相关方法和应用场景进行详细介绍。