摘要

本文从CAS的基本操作开始，逐步探究CAS的实现原理，本文涉及代码使用JDK1.8版本；

CAS是什么？

CAS是Compare And Swap (Compare And Exchange) 的简称，从因为的意思也很容易理解：比较并交换。

先看一段代码，两个线程分别对atomicInteger加100，因为AtomicInteger是可以保证++是原子操作的，所以最终输出结果是：200

public class CasDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(0);
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                atomicInteger.incrementAndGet();
            }
        },"a").start();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                atomicInteger.incrementAndGet();
            }
        },"b").start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info(atomicInteger.get());
    }
}

CAS是如何实现的？

AtomicInteger类
在AtomicInteger数据定义的部分，实际存储的值是放在value中的，除此之外获取了unsafe实例，并且定义了valueOffset。再看到static块，根据加载过程，static块的加载发生于类加载的时候，是最先初始化的，这时候调用unsafe的objectFieldOffset从Atomic类文件中获取value的偏移量，那么valueOffset其实就是记录value的偏移量的。

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;
    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    private volatile int value;
    ...
}

再看一下incrementAndGet函数
var5 = this.getIntVolatile(var1, var2); // 取出Object中偏移地址为var2的值var5；
this.compareAndSwapInt(var1, var2, var5, var5 + var4)比较var1中偏移量为var2的值是否和var5相等？相等则更新为var5 + var4；参数换个名字应该会清晰很多：compareAndSwapInt（obj, offset, expect, update）；

 /**
 * Atomically increments by one the current value.
 *
 * @return the updated value
 */
public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        // 取出Object中偏移地址为var2的值var5；
        var5 = this.getIntVolatile(var1, var2);
        // 比较var1中偏移量为var2的值是否和var5相等？相等则更新为var5 + var4；
    } while (!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

问题来了？比较并交换就是也是两个步骤，怎么能保证线程同步呢？
下载一下Hotspot源码，看到compareAndSwapInt实现的源码如图所示，发现最终调用了Atomic::cmpxchg(x, addr, e)方法。

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

JNI

翻看源码（如下面两张图所示）可以看到，不同的平台有不同的实现方式；

在x86的架构下实现，是通过LOCK_IF_MP加锁的方式实现
os::is_MP判断当前系统是否为多核系统，如果是就给总线加锁，所以同一芯片上的其他处理器就暂时不能通过总线访问内存，保证了该指令在多处理器环境下的原子性。
asm说明是ASM汇编，volatile禁止编译器优化，

// Adding a lock prefix to an instruction on MP machine
#define LOCK_IF_MP(mp) "cmp $0, " #mp "; je 1f; lock; 1: "

cmpxchg

在atomic.cpp中则是通过递归实现的；

因为根据IA64手册，X86_64架构下，不跨越cacheline的8byte读写是原子的，如果你有个指针，没有跨越cacheline，那么多线程对这个指针的复制和读取都是不需要加锁的，可以保证原子的读到这8byte；

在这里插入图片描述

CAS存在的问题？

ABA的问题
CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。这就是CAS的ABA问题。
常见的解决思路是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A-B-A 就会变成1A-2B-3A。
目前在JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。
循环时间长开销大
如果CAS不成功，则会原地自旋，如果长时间自旋会给CPU带来非常大的执行开销。

你的鼓励也是我创作的动力

打赏地址

深入刨析CAS

深入刨析CAS

摘要

CAS是什么？

CAS是如何实现的？

CAS存在的问题？

你的鼓励也是我创作的动力