Java CAS

CAS和LockSupport可以说贯穿了java并发包（自旋锁 + CAS + LockSupport + 内存屏障 + 各种等待队列）。

以openjdk7源码为例，jdk/src/share/classes/sun/misc/Unsafe.java:863 compareAndSwapObject方法的注释的注释已经说明的很清晰了

/**
* Atomically update Java variable to x if it is currently
* holding expected.
* @return true if successful
*/
public final native boolean compareAndSwapObject(Object o, long offset,Object expected,Object x);

如果当前对象o偏移offset所对应的对象为expected，则把expected对象自动更新为x，如果更新成功，返回true。此过程是保证原子性的。

对应的jvm源码实现：hotspot/src/share/vm/prims/unsafe.cpp:1136：

// JSR166 ------------------------------------------------------------------

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h))
  UnsafeWrapper("Unsafe_CompareAndSwapObject");
  //更新后的值 
  oop x = JNIHandles::resolve(x_h);
  //内存期望值
  oop e = JNIHandles::resolve(e_h);
  //要改变的对象
  oop p = JNIHandles::resolve(obj);
  //获取要更新的对象偏移地址
  HeapWord* addr = (HeapWord *)index_oop_from_field_offset_long(p, offset);
  if (UseCompressedOops) {
    update_barrier_set_pre((narrowOop*)addr, e);
  } else {
    update_barrier_set_pre((oop*)addr, e);
  }
  //执行CAS操作
  oop res = oopDesc::atomic_compare_exchange_oop(x, addr, e);
  jboolean success  = (res == e);
  if (success)
    update_barrier_set((void*)addr, x);
  return success;
UNSAFE_END

update_barrier_set_pre 和 update_barrier_set与垃圾收集有关，暂时不做讨论，主要看

oopDesc::atomic_compare_exchange_oop(x, addr, e);

hotspot/src/share/vm/oops/oop.inline.hpp:300

inline oop oopDesc::atomic_compare_exchange_oop(oop exchange_value,
                                                volatile HeapWord *dest,
                                                oop compare_value) {
  if (UseCompressedOops) {
    // encode exchange and compare value from oop to T
    narrowOop val = encode_heap_oop(exchange_value);
    narrowOop cmp = encode_heap_oop(compare_value);

    narrowOop old = (narrowOop) Atomic::cmpxchg(val, (narrowOop*)dest, cmp);
    // decode old from T to oop
    return decode_heap_oop(old);
  } else {
    return (oop)Atomic::cmpxchg_ptr(exchange_value, (oop*)dest, compare_value);
  }
}

在linux平台下，会执行

inline jlong    Atomic::cmpxchg    (jlong    exchange_value, volatile jlong*    dest, jlong    compare_value) {
  bool mp = os::is_MP();
  __asm__ __volatile__ (LOCK_IF_MP(%4) "cmpxchgq %1,(%3)"
                        : "=a" (exchange_value)
                        : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                        : "cc", "memory");
  return exchange_value;
}

其中LOCK_IF_MP的定义:

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

其中is_MP是os的静态内联方法，实现在os.cpp中，判断当前系统是否是多处理器的。
asm表示后面的代码是内嵌汇编，volatile表示编译器不要优化代码，后面的指令保持原样。内嵌汇编语的表达格式是：

__asm__(
    "汇编语句模板"
    :输出
    :输入
    :破坏描述
)

代码中的”=a”中=表示输出，而“a”表示eax寄存器，变量前的“r”表示任意寄存器，“cc”表示告诉编译器该指令的执行将影响到标志寄存器，要每次重新读取，而“memory”则是告诉编译器该指令需要重新从内存中读取变量的最新值，而不要从缓存了的寄存器中读取。

LOCK_IF_MP是个宏定义，包含了多条汇编指令(汇编中指令用分号或换行来分隔)。该宏的注释写得很清楚，如果是在多处理器机器上则添加lock前缀，如果是单处理器则只需要执行cmpxchgl指令。lock前缀属于内存屏障，它的作用是在执行后面指令的过程中锁总线(或者是锁cacheline)，保证一致性。后面的cmpxchgl(即Compare and Exchange，末尾的l表示操作数长度为4)就是Intel x86的比较并交换汇编指令。

LOCK_IF_MP和后面的cmpxchgl指令合起来就类似如下汇编语句：
cmp $0, #mp               //$0表示立即数0，cmp是比较指令，若mp等于0则会置标志位ZF=1，ZF即Zero Flag
je 1f                              //je为跳转指令，当ZF=1时，je des表示跳转到des处，此处表示跳转到标签1
lock                              //lock前缀
1: cmpxchgl %1,(%3) //1表示一个标签，类似goto语句的标签

原文：https://blog.csdn.net/prstaxy/article/details/51802220

cmpxchgl的详细执行过程：
首先，输入是"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。
因此，cmpxchgl %1,(%3)实际上表示cmpxchgl exchange_value,(dest)，此处(dest)表示dest地址所存的值。需要注意的是cmpxchgl有个隐含操作数eax，其实际过程是先比较eax的值(也就是compare_value)和dest地址所存的值是否相等，如果相等则把exchange_value的值写入dest指向的地址。如果不相等则把dest地址所存的值存入eax中。
输出是"=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失败。
假设原值为old，存在ptr所执行的位置，想写入新值new，那么cmpxchg实现的功能就是比较old和ptr指向的内容，如果相等则ptr所指地址写入new，然后返回old，如果不相等则把ptr当前所指向地址存的值返回。