java 底层CAS原理

CAS

Compare and Swap, 翻译成比较并交换。

CAS是一种系统原语,原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

java.util.concurrent包中借助CAS实现了区别于synchronize同步锁的一种乐观锁。

乐观锁思路就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。某个线程可以不让出cpu,而是一直while循环，如果失败就重试，直到成功为止。所以，当数据争用不严重时，乐观锁效果更好。比如CAS就是一种乐观锁思想的应用。

CAS应用

CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

所谓原子操作类，指的是java.util.concurrent.atomic包下，一系列以Atomic开头的包装类。例如AtomicBoolean，AtomicInteger，AtomicLong。它们分别用于Boolean，Integer，Long类型的原子性操作。

举例：

private static AtomicInteger num = new AtomicInteger(10);
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 2; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "获取变量值:" + num.get()); // 1
                    if (num.compareAndSet(10, 11)) {  //2
                        System.out.println(Thread.currentThread().getName() + ":修改成功！");
                    } else { //3
                        System.out.println(Thread.currentThread().getName() + ":重试机制");
                        System.out.println(Thread.currentThread().getName() + "获取变量值:" + num.get()); //4
                        if (num.compareAndSet(11, 12)) { //5
                            System.out.println(Thread.currentThread().getName() + ":修改成功2！");
                        }
                    }
                }
            }, "thread" + i);
            thread.start();
        }
    }

结果：

thread0获取变量值:10  
thread0:修改成功！
thread1获取变量值:10
thread1:重试机制
thread1获取变量值:11
thread1:修改成功2！

以上代码，模拟了CAS机制下，2个线程执行的一个过程：

1. thread0和thread1 在代码1处都初次获取了共享变量的值
2. thread0在代码2处利用cas机制比较并修改了内存中变量的值由10修改为11；（注意cas是原子操作此过程是不可被打断的）
3. thread1 执行1处代码，发现预期值和内存中变量值不相等，进入到else分支中的重试机制，更新自身的预期值 = 内存值，再次进行重试，发现预期值11 = 内存变量值，修改成功！

CAS中的ABA问题

如果一开始位置V得到的旧值是A，当进行赋值操作时再次读取发现仍然是A，并不能说明变量没有被其它线程改变过。有可能是其它线程将变量改为了B，后来又改回了A。大部分情况下ABA问题不会影响程序并发的正确性，如果要解决ABA问题，用传统的互斥同步可能比原子类更高效。
举例：

private static AtomicInteger num = new AtomicInteger(10);
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 2; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "获取变量值:" + num.get());
                    if (num.compareAndSet(10, 11)) {
                        System.out.println(Thread.currentThread().getName() + ":修改成功！");
                        num.set(10);  //1
                    } else {
                        System.out.println(Thread.currentThread().getName() + ":重试机制"); //2
                        run();
                    }
                }
            }, "thread" + i);
            thread.start();
        }
    }

结果：

thread0获取变量值:10
thread0:修改成功！
thread1获取变量值:10
thread1:修改成功！

thread0获取变量值:10
thread1获取变量值:10
thread0:修改成功！
thread1:重试机制
thread1获取变量值:10
thread1:修改成功！

经过多次执行，我们可以发现，输出结果不一样：
第一个结果分析：

1. thread0获取了变量值，cas修改成功；
2. thread0把变量值由10修改为11后，由立刻修改回来，把 11 修改为 10；
3. thread1此时获取变量值为10 和自己预期值一样，直接进行修改10为11，修改成功

第2个结果分析：

1. 开始 thread0和thread1都获取了变量值
2. thread0获取cpu资源，cas机制下，预期值10和内存中变量值相等，修改成功;
3. thread1在cas机制下，比较发现预期值10和内存值11不相等，于是进入到else分支开始重试;执行到代码2 处
4. 此时，thread0上，执行了num.set(10)把变量11修改为10;
5. thread1读取主内存的变量值作为预期值，开始进行cas修改，发现预期值=内存值，修改成功（注意此时，线程0已经结束了，并不会再出现线程1读取主内存的值做为预期值到修改主内存的值这段时间内，其他线程对主内存的值进行修改），这里我们运行多次，会发现运行结果并不只有上面两种，这也是多线程的一个特点，另外重试的次数也跟thread0执行set(10)的时机有关。

ABA问题的解决办法

1.在变量前面追加版本号：每次变量更新就把版本号加1，则A-B-A就变成1A-2B-3A。

2.atomic包下的AtomicStampedReference类：其compareAndSet方法首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用的该标志的值设置为给定的更新值。