深入学习CAS原理

概述

在平时多线程开发中，一般为了保持代码的同步性，不使代码在多线程环境下出错，都会给代码加synchronized锁，这样固然会使问题得到解决。但是每次在调用对应方法时候，都会获取或者等待锁释放，会有一定的性能问题，因为线程从阻塞到运行，都会有对应的状态切换，可能线程状态切换的时间比同步代码块的执行时间还长，这样性能会受到一定程度的影响。这时候就可以引入本章要介绍的话题，CAS

CAS是什么

CAS是英文单词CompareAndSwap的缩写，中文的意思是：比较并替换。底层通过利用 CPU 的 CAS 指令对缓存加锁或总线加锁的方式来实现多处理器之间的原子操作，是一种通过硬件实现并发安全的常用技术。底层会根据操作系统和处理器的不同来选择对应的调用代码。

以 Windows 和 X86 处理器为例，如果是多处理器，通过带 lock 前缀的 cmpxchg 指令对缓存加锁或总线加锁的方式来实现多处理器之间的原子操作；如果是单处理器，通过 cmpxchg 指令完成原子操作。

tip:详细C层代码可以看文章参考链接

通过它，实现不能打断的数据交换操作，CPU的特殊指令，由CPU保证原子性

实现过程

CAS需要有3个操作数：内存地址V，旧的预期值A，即将要更新的目标值B。

CAS指令执行时，当且仅当内存地址V的值与预期值A相等时，将内存地址V的值修改为B，否则就什么都不做。整个比较并替换的操作是一个原子操作。

注：t1，t2线程是同时更新同一变量56的值

因为t1和t2线程都同时去访问同一变量56，所以他们会把主内存的值完全拷贝一份到自己的工作内存空间，所以t1和t2线程的预期值都为56。

假设t1在与t2线程竞争中线程t1能去更新变量的值，而其他线程都失败。（失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次发起尝试）。t1线程去更新变量值改为57，然后写到内存中。此时对于t2来说，内存值变为了57，与预期值56不一致，就操作失败了（想改的值不再是原来的值）。

（上图通俗的解释是：CPU去更新一个值，但如果想改的值不再是原来的值，操作就失败，因为很明显，有其它操作先改变了这个值。）

就是指当两者进行比较时，如果相等，则证明共享数据没有被修改，替换成新值，然后继续往下运行；如果不相等，说明共享数据已经被修改，放弃已经所做的操作，然后重新执行刚才的操作。容易看出 CAS 操作是基于共享数据不会被修改的假设，采用了类似于数据库的commit-retry 的模式。当同步冲突出现的机会很少时，这种假设能带来较大的性能提升。

等价代码

/**
 * 描述：     模拟CAS操作，等价代码
 */
public class TwoThreadsCompetition implements Runnable {
     

    private volatile int value;

    public synchronized int compareAndSwap(int expectedValue, int newValue) {
     
        int oldValue = value;
        if (oldValue == expectedValue) {
     
            value = newValue;
        }
        return oldValue;
    }

    public static void main(String[] args) throws InterruptedException {
     
        TwoThreadsCompetition r = new TwoThreadsCompetition();
        r.value = 0;
        Thread t1 = new Thread(r,"Thread 1");
        Thread t2 = new Thread(r,"Thread 2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(r.value);
    }

    @Override
    public void run() {
     
        compareAndSwap(0, 1);
    }
}

应用场景

乐观锁、并发容器、原子类

以AtomicInteger为例，分析在Java中是如何利用CAS实现原子操作的？

public class AtomicInteger extends Number implements java.io.Serializable {
     
    private static final long serialVersionUID = 6214790243416807050L;

//Unsafe，它提供了硬件级别的原子操作
    private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
//内存中的偏移地址  
    private static final long VALUE;

    static {
     
        try {
     
            VALUE = U.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (ReflectiveOperationException e) {
     
            throw new Error(e);
        }
    }

//用volatile修饰value字段，保证可见性
    private volatile int value;
...
	
    /**
     * Atomically adds the given value to the current value.
     *
     * @param delta the value to add
     * @return the previous value
     */
    public final int getAndAdd(int delta) {
     
        return U.getAndAddInt(this, VALUE, delta);
    }
}   

//Unsafe类
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;
}

以getAndAddInt分析

拿到内存位置的最新值v，使用CAS尝试修将内存位置的值修改为目标值v+delta，如果修改失败，则获取该内存位置的新值v，然后继续尝试，直至修改成功。

利用到工具类Unsafe，Unsafe是CAS的核心类，Java无法直接访问底层操作系统，而是通过本地（native）方法来访问。不过尽管如此，jvm还是开了一个后门，jdk中有一个类Unsafe，它提供了硬件级别的原子操作。

VALUE，表示的是变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的原始的，这样我们就能通过unsafe来实现CAS。

CAS的缺点

ABA的问题

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

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

如果在这段期间它的值曾经被改成了B，后来又被改回为A，那CAS操作就会误认为它从来没有被改变过。这个漏洞称为CAS操作的“ABA”问题。Java并发包为了解决这个问题，提供了一个带有标记的原子引用类“AtomicStampedReference”，它可以通过控制变量值的版本来保证CAS的正确性。因此，在使用CAS前要考虑清楚“ABA”问题是否会影响程序并发的正确性，如果需要解决ABA问题，改用传统的互斥同步可能会比原子类更高效。

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

当对一个变量执行操作时，我们可以使用循环 CAS 的方式来保证原子操作，但是对多个变量操作时，CAS 目前无法直接保证操作的原子性。但是我们可以通过以下两种办法来解决：1）使用互斥锁来保证原子性；2）将多个变量封装成对象，通过 AtomicReference 来保证原子性。

自旋时间过长

CAS 通常是配合无限循环一起使用的，我们可以看到 getAndAddInt 方法执行时，如果 CAS 失败，会一直进行尝试。如果 CAS 长时间一直不成功，可能会给 CPU 带来很大的开销。

参考

1.深入理解CAS算法原理

2.面试必问的CAS，你懂了吗？