面试考点（八）——解析CAS操作

什么是CAS

CAS（Compare And Swap），比较并替换。
CAS需要有3个操作数：内存地址V，旧的预期值A，即将要更新的目标值B。
CAS指令执行时，当且仅当内存地址V的值与预期值A相等时，将内存地址V的值修改为B，否则就什么都不做。

整个比较并替换的操作是一个原子操作。

CAS的优点

在并发量不是很高时cas机制会提高效率

• CAS通过自旋的方式实现原子操作，避免了上下文的切换。
  JVM中的CAS操作正是利用处理器的CMPXCHG指令实现。

CAS的缺点

CAS虽然很高效的解决了原子操作问题，但是CAS仍然存在三大问题：

• 循环时间长开销很大。
• 只能保证一个共享变量的原子操作。
• ABA问题。

以下面的代码为例：

	public static volatile int race = 0;

    private static final int THREADS_COUNT = 20;

    private static CountDownLatch countDownLatch = new CountDownLatch(THREADS_COUNT);

    public static void increase() {
        race++;
    }

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        increase();
                    }
                    countDownLatch.countDown();
                }
            });
            threads[i].start();
        }
        countDownLatch.await();
        System.out.println(race);
    }

部分源码：

输出：始终是一个小于200000的数字

循环时间长开销很大：

当getAndAddInt方法执行时，如果CAS失败，会一直进行尝试。如果CAS长时间一直不成功，可能会给CPU带来很大的开销。

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

当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁来保证原子性。

ABA问题：

ABA问题流程如下：

• 1）首先从地址 V 读取值 A；
• 2）根据 A 计算目标值 B；
• 3）通过 CAS 以原子的方式将地址 V 中的值从A 修改为 B。

但是在第1步中读取的值是A，并且在第3步修改成功了，我们就能说它的值在第1步和第3步之间没有被其他线程改变过了吗？

答：如果在这段期间它的值曾经被改成了B，后来又被改回为A，那CAS操作就会误认为它从来没有被改变过。这个漏洞称为CAS操作的“ABA”问题。

解决办法：

为了解决这个问题，java在java.util.concurrent.atomic这个包中提供了带有标记的原子引用类，可以通过控制变量值的版本来保证CAS的正确性。

    private static final int THREADS_COUNT = 20;

    private static CountDownLatch countDownLatch = new CountDownLatch(THREADS_COUNT);

    private static AtomicInteger race=new AtomicInteger();

    public static void increase() {
        race.getAndIncrement();
    }

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        increase();
                    }
                    countDownLatch.countDown();
                }
            });
            threads[i].start();
        }
        countDownLatch.await();
        System.out.println(race);
    }

所以，在使用CAS前要考虑清楚“ABA”问题是否会影响程序并发的正确性。如果需要解决ABA问题，改用传统的互斥同步可能会比原子类更高效。