Java并发编程之CAS原理分析

概述

CAS(Compare and Swap)，从字面意思上理解即：比较和交换。用于实现多线程同步的原子指令。

它将内存位置的内容与给定值进行比较，只有在相同的情况下，将该内存位置的内容修改为新的给定值。

这是作为单个原子操作完成的， 原子性保证新值基于最新信息计算，如果该值在同一时间被另一个线程更新，则写入将失败。

如何实现原子操作

我相信如果问你在Java中实现原子操作，你首先会想到的就是使用锁机制来保证原子性，比如使用最常见的synchronized关键字，但是synchronized是一种独占锁，而独占锁本质上又属于悲观锁，它会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。

而另一个更加有效的锁就是乐观锁。所谓乐观锁就是，每次都不加锁而是假设没有冲突去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁用到的机制就是自旋CAS(Compare and Swap)，在JVM中的CAS操作就是利用了处理器提供的CMPXCHG指令实现的。

从Java 1.5开始，JDK的并发包里提供了一些类来支持原子操作，如AtomicBoolean(用原子方式更新的boolean值)、AtomicInteger(用原子方式更新的int值)和AtomicLong(用原子方式更新的long值)。这些原子包装类还提供了有用的工具方法，比如以原子的方式将当前值自增1和自减1。

开始了解CAS

我们还是以AtomicInteger这个类来进行简单分析其中incrementAndGet这个方法

JDK 1.8的源码实现：

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

JDK 1.7的源码实现：

public final int incrementAndGet() {
    for (;;) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next)){
            return next;
        }
    }
}

从JDK 1.7源码中看的比较清楚，内部实现其实就是将当前的内存值和期望的值进行对比，如果相同则返回期望值，笔者这里直接使用书上的一个例子(实现了一个基于CAS线程安全的计数器方法safeCount和一个非线程安全的计数器count)，来理解自旋CAS。

public class Counter {

    private AtomicInteger atomicCounter = new AtomicInteger(0);

    private int i = 0;

    public static void main(String[] args) {
        final Counter cas = new Counter();
        List<Thread> ts = new ArrayList<>(600);
        long start = System.currentTimeMillis();
        for (int j = 0; j < 100; j++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        cas.count();
                        cas.safeCount();
                    }
                }
            });
            ts.add(thread);
        }
        for (Thread thread : ts) {
            thread.start();
        }
        // 等待所有线程执行完成
        for (Thread t : ts) {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(cas.i);
        System.out.println(cas.atomicCounter.get());
        System.out.println(System.currentTimeMillis() - start);
    }

    /**
     * 使用CAS实现线程安全计数器
     */
    private void safeCount() {
        for (; ; ) {
            int i = atomicCounter.get();
            boolean suc = atomicCounter.compareAndSet(i, ++i);
            if (suc) {
                break;
            }
        }
    }

    /**
     * 非线程安全计数器
     */
    private void count() {
        i++;
    }
}

上面的实现是一个计数器，我们可以看到，在safeCount方法中，会将当前的值和期望的值进行对比，如果成功则中断循环，否则继续重试，直到成功为止。这也是自旋CAS的一个基本思想

CAS实现原子操作的三大问题

1.ABA问题

上面的例子我们也了解了自选CAS的基本作用，那实际操会不会有什么问题呢？要知道它的原理实际是：当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。，这样就可能导致一个问题，如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会认为它的值没有发生变化，但是实际上却变化了。这个问题该如何解决呢？

ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加1，那么A→B→A就会变成1A→2B→3A。从Java 1.5开始，JDK的Atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法的作用是首先检查当前引用是否等于预期引用，并且检查当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

AtomicStampedReference中的compareAndSet方法声明如下：

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

2.循环时间长开销大

上面的例子可以看到，自旋CAS如果长时间不成功，会一直循环，给CPU带来非常大的执行开销。

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

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

参考

《Java并发编程的艺术》