入坑JAVA多线程并发(九）CAS和ABA

　　如果了解数据库的悲观锁和乐观锁的话，对于理解CAS就很简单了，因为CAS就是乐观锁的具体实现。
　　悲观锁：在操作数据库时本能的觉得一定会有竞争，所以把数据锁住，不让其他事物对对应的数据进行操作，在本次操作之后把锁释放，其它事物才可以进行操作。这个在java里面就类似于synchronized。
　　乐观锁：在操作数据库时都觉得不会有其它事物和自己进行竞争，事物开始的时候就把对应的数据取出，在对数据进行更新的时候把数据和之前取出的数据进行对比，如果一样说明没有其他事物进行操作，可以进行操作，如果不一致，说明期间有其它事物对数据进行了操作，那么这次操作失败，进行重试。

1、CAS的三个值

Ｖ：要更新的变量
Ｅ：变量期望的值
Ｎ：变量要更新的值

如上图所示，如果Ｖ和Ｅ的值不符合，就重新取值进行操作，一直到相等执行更新或者符合退出条件为止。

2、原子操作类

有AtomicBoolean，AtomicInteger，AtomicLong，这里以AtomicInteger的代码为例
如下代码：

public class Main {
    static volatile int cas = 0;
    public static void main(String[] args) {
        new Thread(() -> {
            for (int i = 0 ;i < 100; i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                cas++;
            }
            System.out.println(cas);
        }).start();
        new Thread(() -> {
            for (int i = 0 ;i < 100; i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                cas++;
            }
            System.out.println(cas);
        }).start();

    }
}

输出为

173
173

测试多次结果都是小于200，这里volatile只能保证可见性和指令重排。无法确保原子性，这里cas++有三个操作，取出cas的值，加1，同步到主存。所以存在线程安全问题。
如果用AtomicInteger类型

public class Main {
    static AtomicInteger cas = new AtomicInteger(0);
    public static void main(String[] args) {
        new Thread(() -> {
            for (int i = 0 ;i < 100; i++){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                cas.incrementAndGet();
            }
            System.out.println(cas);
        }).start();
        new Thread(() -> {
            for (int i = 0 ;i < 100; i++){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                cas.incrementAndGet();
            }
            System.out.println(cas);
        }).start();

    }
}

输出为

200
200

这里是因为数太小，数据改大一点，第一个数就是小于200的，第二个数会一直等于预期的和，这里就是用了CAS。

incrementAndGetf方法 （1.7和1.8版本）

//1.7版本
public final int incrementAndGet() {
    for (;;) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next))
            return next;
    }
}
//CAS操作
public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

//unsafe类的本地操作方法
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

//1.8版本
//AtomicInteger的incrementAndGet方法
public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

//CAS操作
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;
}

//获取实时的value的值
public native int getIntVolatile(Object var1, long var2);

　　compareAndSwapInt这个方法有四个参数，其中第一个参数为需要改变的对象，第二个为偏移量(即之前求出来的valueOffset的值)，第三个参数为期待的值，第四个为更新后的值。整个方法的作用即为若调用该方法时，value的值与expect这个值相等，那么则将value修改为update这个值，并返回一个true，如果调用该方法时，value的值与expect这个值不相等，那么不做任何操作，并范围一个false；
　　1.7和1.8的不同在于CAS的操作返回值不一样。1.7是直接返回加1后的值，1.8的CAS返回的是原始的值，只是在incrementAndGetf方法内把返回值进行加1再返回。
　　CAS就是循环获取value值，执行compareAndSwapInt方法。返回true就代表执行成功。退出循环。concurrent包很多类都是基于CAS实现的。
　　其它方法包括getAndIncrement、getAndDecrement、getAndAdd、decrementAndGet等就是对int值进行加减运输，内部实现原理和incrementAndGet是一样的

3、ABA问题和AtomicStampedReference类

　　ABA问题：CAS算法实现一个重要前提需要取出内存中某时刻的数据，而在下时刻比较并替换，那么在这个时间差类会导致数据的变化。
　　举个栗子：一个用单向链表实现的堆栈，栈顶为A，这时线程T1已经知道A.next为B，然后希望用CAS将栈顶替换为B，在T1执行之前，线程T2介入，将A、B出栈，再pushD、C、A。此时轮到线程T1执行CAS操作，检测发现栈顶仍为A，所以CAS成功，栈顶变为B，但实际上B.next为null。具体如下图
　　
解决方法就是添加一个版本号。乐观锁的一种实现也是通过版本号实现，每一次操作都改变版本号，对比版本号确定是否执行操作。
JAVA中AtomicStampedReference就实现了这种版本标记的功能。

public class Main {

    static AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<>(0,1);
    public static void main(String[] args) {
        new Thread(() -> {
            for (int i = 0 ;i < 1000; i++){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                stampedReference.compareAndSet(stampedReference.getReference(),stampedReference.getReference()+1,stampedReference.getStamp(),stampedReference.getStamp()+1);
            }
            System.out.println(stampedReference.getReference());
        }).start();
        new Thread(() -> {
            for (int i = 0 ;i < 1000; i++){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                stampedReference.compareAndSet(stampedReference.getReference(),stampedReference.getReference()+1,stampedReference.getStamp(),stampedReference.getStamp()+1);
            }
            System.out.println(stampedReference.getReference());
        }).start();

    }
}

输出为：

1970
1971

重复测试多次输出一直是两个小于2000的数字，因为两个线程一起操作。会存在线程2在操作期间线程1已经把数字更新了，线程2就会操作失败。所以最终的结果一定会和预期不符。