深入理解CAS原子操作

1、什么是CAS

CAS是Compare And Swap的缩写，比较与交换，通常指的是这样一种原子操作：针对一个变量，首先比较它的内存值和某个期望值是否相同，如果相同，就给它赋一个新值。

CAS的逻辑伪代码描述如下：

if (value == expectedValue) {
    value = newValue;
}

以上伪代码描述了一个由比较和赋值两阶段组成的符合操作。CAS可以看作是他们合并后的整体---

一个不可分割的原子操作，并且其原子性是直接在硬件层面得到保障的。

CAS可以看作是乐观锁(对比数据库的悲观、乐观锁)的一种实现方式，Java原子类中的递增操作就

是通过CAS自旋实现的。

CAS是一种无锁算法，在不使用锁的情况下实现多线程之间的变量同步。

以下是CAS的实现流程图：

2、CAS的引用

在Java中，CAS操作是由Unsafe类提供支持的，该类定义了三种针对不同类型变量的CAS操作，图下：

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

它们都是native方法，由Java虚拟机提供具体实现，这意味着不同的Java虚拟机对它们的实现可能会略有不同。以compareAndSwapInt为例，Unsafe的compareAndSwapInt方法接收四个参数，分别是：对象实例、内存偏移量、字段期望值、字段新值。该方法会针对指定对象实例中的相应偏移量的字段执行CAS操作。代码实例如下：

package juc.atomic;

import juc.factory.UnsafeFactory;
import sun.misc.Unsafe;

public class CASTest {

    public static void main(String[] args) {

        Entity entity = new Entity();
        Unsafe unsafe = UnsafeFactory.getUnsafe();
        boolean successful;
        //获取偏移量
        long offset = UnsafeFactory.getFieldOffset(unsafe,Entity.class, "x");
        //四个参数:对象实例、字段的内存偏移量、字段期望值、字段更新值
        successful = unsafe.compareAndSwapInt(entity, offset, 0, 3);
        System.out.println(successful+"\t"+entity.x);
        successful = unsafe.compareAndSwapInt(entity, offset, 3, 5);
        System.out.println(successful+"\t"+entity.x);
        successful = unsafe.compareAndSwapInt(entity, offset, 3, 8);
        System.out.println(successful+"\t"+entity.x);

    }

}

class Entity{
    int x;
}

package juc.factory;
import sun.misc.Unsafe;
import java.lang.reflect.Field;

public class UnsafeFactory {

    /**
     * 获取 Unsafe 对象
     * @return
     */
    public static Unsafe getUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取字段的内存偏移量
     * @param unsafe
     * @param clazz
     * @param fieldName
     * @return
     */
    public static long getFieldOffset(Unsafe unsafe, Class clazz, String fieldName) {
        try {
            return unsafe.objectFieldOffset(clazz.getDeclaredField(fieldName));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }

}

 测试：针对entity.x的3次CAS操作，分别试图将它从0改成3、从3改成5、从3改成8，执行结果如下图：

3、CAS源码分析

Hotspot虚拟机对compareAndSwapInt方法的实现如下：

#unsafe.cpp
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jo
bject obj, jlong offset, jint e, jint x))
UnsafeWrapper("Unsafe_CompareAndSwapInt");
oop p = JNIHandles::resolve(obj);
// 根据偏移量，计算value的地址
jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
// Atomic::cmpxchg(x, addr, e) cas逻辑 x:要交换的值 e:要比较的值
//cas成功，返回期望值e，等于e,此方法返回true
//cas失败，返回内存中的value值，不等于e，此方法返回false
return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

核心逻辑在Atomic::cmpxchg方法中，这个根据不同操作系统和不同CPU会有不同的实现。这里我们以linux_64x为例，查看Atomic::cmpxchg的实现：

#atomic_linux_x86.inline.hpp
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value){
    //判断当前执行环境是否为多处理器环境
    int mp = os::is_MP();
    //LOCK_IF_MP(%4) 在多处理器环境下，为 cmpxchgl 指令添加 lock 前缀，以达到内存屏障的效果
    //cmpxchgl 指令是包含在 x86 架构及 IA‐64 架构中的一个原子条件指令，
    //它会首先比较 dest 指针指向的内存值是否和 compare_value 的值相等，
    //如果相等，则双向交换 dest 与 exchange_value，否则就单方面地将 dest 指向的内存值交给exchange_value。
    //这条指令完成了整个 CAS 操作，因此它也被称为 CAS 指令。
    __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
    : "=a" (exchange_value)
    : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
    : "cc", "memory");
    return exchange_value;
}

cmpxchg的详细执行过程：

首先，输入是"r"（exchange_value），"a"（compare_value）,"r"(dest)，"r"(mp),表示compare_value存入eax寄存器，而exchange_value、dest、mp的值存入任意的通用寄存器。嵌入式汇编规定把输出和输入寄存器按统一顺序编号，顺序是从输出寄存器序列从左到右从上到下以"%0"开始，分别记'%0'、"%1"..."9%"。也就是说，输出的eax是"%0",输入的exchange_value、compare_value、dest、mp分别是%1、%2、%3、%4.因此cmpxchg%1,(%3)实际上表示cmpxchg exchange_value,(dest)，需要注意的是cmpxchg有个隐含操作数eax，其实际过程中是先比较eax的值（也就是compare_value）和dest地址所存的值是否相等，输出"=a"(exchange_value),表示把eax中存的值写入exchange_value变量中。

Atomic::cmpxchg这个函数最终返回值是exchange_value，也就是说，如果cmpxchgl执行时compare_value和dest指针指向内存值相等则会使得dest指针指向内存值变成 exchange_value，最终eax存的compare_value赋值给了exchange_value变量，即函数最 终返回的值是原先的compare_value。此时Unsafe_CompareAndSwapInt的返回值(jint) (Atomic::cmpxchg(x, addr, e)) == e就是true，表明CAS成功。如果cmpxchgl执行时 compare_value和(dest)不等则会把当前dest指针指向内存的值写入eax，最终输出时赋值 给exchange_value变量作为返回值，导致(jint)(Atomic::cmpxchg(x, addr, e)) == e得到false，表明CAS失败。

不管是Hotspot中的Atomic::cmpxchg方法，还是Java中的compareAndSwapInt方法，它们本质上都是对相应平台的CAS指令的一层简单封装。CAS指令作为一种硬件源语，有着天然的原子性，这也正是CAS的价值所在，CAS不存在线程由用户态到内核态的切换。

4、CAS缺陷

CAS虽然高效的解决了原子操作，但是还是存在一些缺陷，主要表现为以下三个方面：

• 自旋CAS长时间的不成功，则会给CPU带来非常大的开销。
• 只能保证一个共享变量原子操作。
• ABA问题