CAS

CAS 原理：

CAS（Compare and Swap）有三个参数，内存值V、旧的预期值A、即将更新的值B，当且仅当预期值 A 和内存值 V 相同时，将内存值修改为B并返回true，否则什么都不做，并返回false。

java 中的应用

1. java.util.concurrent(J.U.C) 中提供的 atomic 包中的类，使用的是乐观锁，用到的机制就是CAS，当多个线程尝试使用 CAS 同时更新一个变量时，只有其中一个线程可能更新变量的值，而其他线程都失败，失败的线程不会被挂起，而是被告知这次竞争失败，并可以再次尝试。
2. 以 AtomicInteger 为例，研究在没有锁的情况下是如何做到数据正确性的。

public class AtomicInteger extends Number implements java.io.Serializable {
    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;
    public final int get() {return value;}
}

例如 AtomicInteger 中有一个原子方式 i++ 操作，即

1. 调用 incrementAndGet(),而 incrementAndGet() 调用 unsafe下的方法 getAndAddInt()

public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 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));

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

2. getAndAddInt() 中有一个 valueOffset 参数，这个值是 value 值在 AtomicInteger 类型中内存的偏移地址。传入的 valueOffset 参数会在后续方法中，直接从内存位置读取这个字段的值。
3. 得到最新值后，调用 compareAndSwapInt 来更新最新值，如果对象中 offset 偏移位置的值等于期望值(expected)，就将该 offset 处的值更新为 x，当更新成功时，返回 true。结合前面调用来看，如果当前值是 v，就设置为 v+1。否则重试直到成功为止。
   不仅仅是 AtomicInteger 用到了 CAS，整个 java.util.concurrent 中所有无阻塞共享内存和锁的实现都是基于 CAS 实现的。

CAS 缺点

1. ABA问题。
   因为 CAS 需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用 CAS 进行检查时会发现它的值没有发生变化，但是实际上却变化了。
   ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。
   从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。
2. 循环时间长开销大。
   自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。如果JVM能支持处理器提供的pause指令那么效率会有一定的提升，pause指令有两个作用，第一它可以延迟流水线执行指令（de-pipeline）,使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。
3. 只能保证一个共享变量的原子操作。
   当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i＝2,j=a，合并一下ij=2a，然后用CAS来操作ij。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。

atomic原子类

1. 原子类由 CAS 操作保证原子性，由 volatile 关键字保证可见性。
2. 可以粗略分成五类：

1. 整型、长整型、布尔型、引用类型的原子类
   AtomicInteger、AtomicLong、AtomicBoolean、AtomicReference
2. 整型数组、长整型数组、引用数组的原子类
   AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
3. 整型字段、长整型字段、引用字段更新的原子类
   AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater
4. 解决ABA问题的原子类
   AtomicMarkableReference、AtomicStampedReference
5. jdk 1.8新增的更高性能的原子累加器
   LongAdder、DoubleAdder、LongAccumulator、DoubleAccumulator

3. 原子类的底层操作都是通过 Unsafe 类完成，每个原子类内部都有一个 Unsafe 类的静态引用。Unsafe 类中大部分都是native方法。

private static final Unsafe unsafe = Unsafe.getUnsafe();

4. AtomicInteger 内部由一个 int 域来保存值，其由volatile关键字修饰，用于保证可见性。类似的，AtomicLong内部是一个long型的value，AtomicBoolean 内部也是一个int，但其只会取值0或1。

private volatile int value;

5. AtomicInteger中有一个 compareAndSet 方法，通过 CAS 对变量进行原子更新。它通过调用 Unsafe 的 native函数实现：unsafe.compareAndSwapInt(this, valueOffset, expect, update)。