Java并发编程之CAS与ABA

了解CAS（Compare-And-Swap）

原子操作可以使用锁机制实现，比如使用synchronized，但是synchronized是很耗费资源的，当一个线程持有锁的时候，其他线程就不能访问共享资源，必须等到持有锁的线程释放该锁，CPU会耗费大量资源来处理这些锁的竞争以及线程间的切换。 可以使用CAS代替锁的使用。

CAS原理

CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存地址V里面的值和A的值是一样的，那么就将内存里面的值更新成B。CAS是通过无限循环来获取数据的，若果在第一轮循环中，a线程获取地址里面的值被b线程修改了，那么a线程需要自旋，到下次循环才有可能机会执行。

原子变量类

JDK5.0之后加入了java.util.concurrent.atomic 包，其中的AtomicInteger、 AtomicLong、 AtomicReference、AtomicBoolean、AtomicStampedRerence、AtomicMarkableReference等都是在CAS基础上实现的。

CAS的问题

1.CAS容易造成ABA问题。

ABA：一个线程将某一内存地址中的数值A改成了B，接着又改成了A，此时CAS认为是没有变化，其实是已经变化过了，而这个问题的解决方案可以使用版本号标识，每操作一次version加1。在java5中，已经提供了AtomicStampedReference来解决问题。

AtomicInteger的ABA问题

public static AtomicInteger a = new AtomicInteger(1);
public static void main(String[] args){
    Thread main = new Thread(() -> {
        System.out.println("操作线程" + Thread.currentThread() +",初始值 = " + a);  //定义变量 a = 1
        try {
            Thread.sleep(1000);  //等待1秒 ，以便让干扰线程执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        boolean isCASSuccess = a.compareAndSet(1,2); // CAS操作
        System.out.println("操作线程" + Thread.currentThread() +",CAS操作结果: " + isCASSuccess);
    },"主操作线程");

    Thread other = new Thread(() -> {
        Thread.yield();  //确保thread-main线程优先执行
        a.incrementAndGet(); // a 加 1, a + 1 = 1 + 1 = 2
        System.out.println("操作线程" + Thread.currentThread() +",【increment】 ,值 = "+ a);
        a.decrementAndGet(); // a 减 1, a - 1 = 2 - 1 = 1
        System.out.println("操作线程" + Thread.currentThread() +",【decrement】 ,值 = "+ a);
    },"干扰线程");

    main.start();
    other.start();
}

运行结果：

// 输出
> 操作线程Thread[主操作线程,5,main],初始值 = 1
> 操作线程Thread[干扰线程,5,main],【increment】 ,值 = 2
> 操作线程Thread[干扰线程,5,main],【decrement】 ,值 = 1
> 操作线程Thread[主操作线程,5,main],CAS操作结果: true

AtomicInteger的ABA问题的解决方案：使用AtomicStampedReference
AtomicStampedReference主要维护包含一个对象引用以及一个可以自动更新的整数"stamp"的pair对象来解决ABA问题。

private static AtomicStampedReference<Integer> atomicStampedRef = 
        new AtomicStampedReference<>(1, 0);

public static void main(String[] args){
    Thread main = new Thread(() -> {
        System.out.println("操作线程" + Thread.currentThread() +",初始值 a = " + atomicStampedRef.getReference());
        int stamp = atomicStampedRef.getStamp(); //获取当前标识别
        try {
            Thread.sleep(1000); //等待1秒 ，以便让干扰线程执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        boolean isCASSuccess = atomicStampedRef.compareAndSet(1,2,stamp,stamp +1);  //此时expectedReference未发生改变，但是stamp已经被修改了,所以CAS失败
        System.out.println("操作线程" + Thread.currentThread() +",CAS操作结果: " + isCASSuccess);
    },"主操作线程");

    Thread other = new Thread(() -> {
        Thread.yield(); // 确保thread-main 优先执行
atomicStampedRef.compareAndSet(1,2,atomicStampedRef.getStamp(),atomicStampedRef.getStamp() +1);
        System.out.println("操作线程" + Thread.currentThread() +",【increment】 ,值 = "+ atomicStampedRef.getReference());
        atomicStampedRef.compareAndSet(2,1,atomicStampedRef.getStamp(),atomicStampedRef.getStamp() +1);
        System.out.println("操作线程" + Thread.currentThread() +",【decrement】 ,值 = "+ atomicStampedRef.getReference());
    },"干扰线程");

    main.start();
    other.start();
}

运行结果：

// 输出
> 操作线程Thread[主操作线程,5,main],初始值 a = 2
> 操作线程Thread[干扰线程,5,main],【increment】 ,值 = 2
> 操作线程Thread[干扰线程,5,main],【decrement】 ,值 = 1
> 操作线程Thread[主操作线程,5,main],CAS操作结果: false

AtomicInteger的ABA问题并不会造成结果错误，但某些情况的CAS操作的ABA问题会产生错误的结果
线程1准备用CAS将变量的值由A替换为B，在此之前，线程2将变量的值由A替换为C，又由C替换为A，然后线程1执行CAS时发现变量的值仍然为A，所以CAS成功。但实际上这时的现场已经和最初不同了，尽管CAS成功，但可能存在潜藏的问题，例如下面的例子：

现有一个用单向链表实现的堆栈，栈顶为A，这时线程T1已经知道A.next为B，然后希望用CAS将栈顶替换为B：

head.compareAndSet(A,B);

在T1执行上面这条指令之前，线程T2介入，将A、B出栈，再pushD、C、A，此时堆栈结构如下图，而对象B此时处于游离状态：

此时轮到线程T1执行CAS操作，检测发现栈顶仍为A，所以CAS成功，栈顶变为B，但实际上B.next为null，所以此时的情况变为：

其中堆栈中只有B一个元素，C和D组成的链表不再存在于堆栈中，平白无故就把C、D丢掉了。

总结：
尽管AtomicInteger有ABA问题，但对程序不会产生错误结果的情况下就可以使用，如果ABA问题会对程序产生错误的结果，则可以使用AtomicStampedReference。具体根据应用来选择不同的原子类或者其他解决方案。

2.循环时间太长，开销大。

如果CAS自旋长时间不成功，会给cpu带来极大的开销。

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

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

AtomicInteger和Integer区别

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * AtomicInteger和Integer区别
 * AtomicInteger可保证在多线程中保持原子操作，适用于在多线程中的计算
 * @author
 */
public class TestAtomicInteger {

    private static Integer integerResult = 0;

    private static AtomicInteger atomicIntegerResult = new AtomicInteger();

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        List<FutureTask<Integer>> futureTaskList = new ArrayList<FutureTask<Integer>>();
        for (int i = 0; i < 10000; i++) {
            FutureTask<Integer> ft = new FutureTask<Integer>(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    integerResult += 1;
                    return atomicIntegerResult.incrementAndGet();
                }
            });
            new Thread(ft).start();
            futureTaskList.add(ft);
        }
        for (int i = 0; i < futureTaskList.size(); i++) {
            futureTaskList.get(i).get();//保证所有的线程执行完成
        }
        System.out.println("integerResult=====" + integerResult);
        System.out.println("atomicIntegerResult====" + atomicIntegerResult.get());
    }
}

运行结果：

integerResult=====2603  //该结果是随机的
atomicIntegerResult====10000

面试相关问题

从AtomicInteger引出下面的问题：
CAS -> Unsafe -> CAS底层思想 -> ABA -> 原子更新基本类型、原子更新数组、原子更新引用 -> 如何规避ABA问题

参考：
JAVA中CAS-ABA的问题解决方案AtomicStampedReference
沉淀再出发：java中的CAS和ABA问题整理
java 中的CAS与ABA问题
Java CAS 和ABA问题

Java中的乐观锁

大厂30K面试题（一）请描述CAS的底层是如何实现的？一百度阿里