深入理解CAS

CAS（compare-and-swap） ，保证数据的原子性，是硬件对于并发操作共享数据的支持
CAS不同于Synchronized，Synchronized是悲观锁，这种线程一旦得到锁，其他需要锁的线程就挂起；而CAS操作的就是乐观锁，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。

CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。
当且仅当V==A时，V = B，否则，不进行任何操作

看看它的源码

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

Unsafe 类

Unsafe 类方法都是本地方法，因为Java无法直接和操作系统打交道，但是C++可以，所以提供了这个通道来间接操作

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

    public native Object getObjectVolatile(Object var1, long var2);

    public native void putObjectVolatile(Object var1, long var2, Object var4);

    public native int getIntVolatile(Object var1, long var2);

再看看 getAndIncrement 操作，类似Java的 i++
有三个参数，第一个是当前对象
第二个是值的偏移量，可以看成是值的内存地址
第三个就是自增1

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

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)); //相等，内存地址值加1

        return var5;
    }

因为cas是直接操作内存，所以效率极高

CAS的缺陷

1.著名的 ABA 问题
2. 只能保证一个共享变量的原子操作
3. 循环时间长开销大

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

简单举例：
线程 1 从内存位置V中取出A。
线程 2 从位置V中取出A。
线程 2 进行了一些操作，将B写入位置V。
线程 2 将A再次写入位置V。
线程 1 进行CAS操作，发现位置V中仍然是A，操作成功。
尽管线程 1 的CAS操作成功，但不代表这个过程没有问题——对于线程 1 ，线程 2 的修改已经丢失。

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

public boolean compareAndSet(
               V      expectedReference,//预期引用
               V      newReference,//更新后的引用
              int    expectedStamp, //预期标志
              int    newStamp //更新后的标志
)

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;

public class Test06 {
    public static void main(String[] args) {

        //原子引用,带 版本号的原子操作 乐观锁
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();//得到当前的版本号
            System.out.println("A -version "+stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            boolean compareAndSet = atomicStampedReference.compareAndSet(1, 2, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println("A IS "+compareAndSet);
            System.out.println("A -version "+atomicStampedReference.getStamp());

            compareAndSet = atomicStampedReference.compareAndSet(2, 1, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println("A IS "+compareAndSet);
            System.out.println("A -version "+atomicStampedReference.getStamp());


        },"a").start();

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();//得到当前的版本号
            System.out.println("B -version "+stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean compareAndSet = atomicStampedReference.compareAndSet(1, 7, stamp, stamp + 1);
            System.out.println("B IS "+compareAndSet);
            System.out.println("B -version "+atomicStampedReference.getStamp());
        },"b").start();
    }
}

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

当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i＝2,j=a，合并一下ij=2a，然后用CAS来操作ij。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。

3、循环时间长开销大

自旋锁，自旋CAS（不成功，就一直循环执行，直到成功）如果长时间不成功，会给CPU带来非常大的执行开销。

        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2); 
            //比较当前工作内存中的值和主内存中的值，如果这个值是期望的，就执行操做，如果不是，就一直循环
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); 

        return var5;
    }