CAS指令

原文链接：https://www.jianshu.com/p/00edb3d74a33

 

CAS是CPU的一条指令，其具有原子性，原子性是由CPU硬件层面保证的。

 

CAS原语有三个操作数——内存位置（V）、预期原值（A）、新值（B）。若内存位置与预期原值匹配则处理器将该位置更新为新值。否则不做操作。无论何种情况都会在CAS指令之前返回该位置值。这个过程是原子性的。

 

底层硬件通过将 CAS 里的多个操作在硬件层面语义实现上，通过一条处理器指令保证了原子性操作。这些指令如下所示：

（1）测试并设置（Tetst-and-Set）

（2）获取并增加（Fetch-and-Increment）

（3）交换（Swap）

（4）比较并交换（Compare-and-Swap）

（5）加载链接/条件存储（Load-Linked/Store-Conditional）

前面三条大部分处理器已经实现，后面的两条是现代处理器当中新增加的。而且根据不同的体系结构，指令存在着明显差异。

在IA64，x86 指令集中有 cmpxchg 指令完成 CAS 功能。

 

sun.misc.Unsafe 中 CAS 的核心方法：

这里的实现和CAS原语基本一致，唯一的区别就是返回类型不一样，CAS指令返回内存地址最新值，这里成功写入返回true，失败返回false

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 var6);

这三个方法可以对应去查看 openjdk 的 hotspot 源码：

源码位置：hotspot/src/share/vm/prims/unsafe.cpp

#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)

{CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z",  FN_PTR(Unsafe_CompareAndSwapObject)},

{CC"compareAndSwapInt",  CC"("OBJ"J""I""I"")Z",      FN_PTR(Unsafe_CompareAndSwapInt)},

{CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z",      FN_PTR(Unsafe_CompareAndSwapLong)},

三个方法，最终在 hotspot 源码实现中都会调用统一的 cmpxchg 函数，可以在 hotspot 源码中找到核心代码。

源码地址：hotspot/src/share/vm/runtime/Atomic.cpp

 

cmpxchg 函数源码：可以看到调用了cmpxchg汇编指令执行CAS操作

jbyte Atomic::cmpxchg(jbyte exchange_value, volatile jbyte*dest, jbyte compare_value) {
         assert (sizeof(jbyte) == 1,"assumption.");
         uintptr_t dest_addr = (uintptr_t) dest;
         uintptr_t offset = dest_addr % sizeof(jint);
         volatile jint*dest_int = ( volatile jint*)(dest_addr - offset);
         // 对象当前值
         jint cur = *dest_int;
         // 当前值cur的地址
         jbyte * cur_as_bytes = (jbyte *) ( & cur);
         // new_val地址
         jint new_val = cur;
         jbyte * new_val_as_bytes = (jbyte *) ( & new_val);
          // new_val存exchange_value，后面修改则直接从new_val中取值
         new_val_as_bytes[offset] = exchange_value;
         // 比较当前值与期望值，如果相同则更新，不同则直接返回
         while (cur_as_bytes[offset] == compare_value) {
          // 调用汇编指令cmpxchg执行CAS操作，期望值为cur，更新值为new_val
             jint res = cmpxchg(new_val, dest_int, cur);
             if (res == cur) break;
             cur = res;
             new_val = cur;
             new_val_as_bytes[offset] = exchange_value;
         }
         // 返回当前值
         return cur_as_bytes[offset];
}

 

ABA问题

CAS操作是判断当前内存中的值与期望值是否相等，相等才更新。但如果第一个线程执行CAS操作，其期望值是对象A，其它线程在这之前吧内存中的值改为了B，又改为了A。这时会判断相等，但实际A的属性可能已经改变，判断条件已经发生了变化，这就产生了线程安全的问题。

解决方法：

　　添加版本号，每次更新内存操作时版本号加1，比较原值的同时比较版本号。

AtomicStampReference

AtomicStampReference在cas的基础上增加了一个标记stamp，使用pair将原数据包裹起来，基于pair进行底层cas操作。

// 类的定义：
public class AtomicStampedReference<V>
// 构造函数，将对象和标记值传入
public AtomicStampedReference(V initialRef, int initialStamp) {
    pair = Pair.of(initialRef, initialStamp);
}
// 参数代表的含义分别是 期望值，写入的新值，期望标记，新标记值
public boolean compareAndSet(V   expectedReference,
                             V   newReference,
                             int expectedStamp,
                             int newStamp) {
    Pair<V> current = pair;
    // 比较原对象的同时比较版本号是否也相同，如果都相同则进行pair的cas操作
    return
        expectedReference == current.reference &&
        expectedStamp == current.stamp &&
        ((newReference == current.reference &&
          newStamp == current.stamp) ||
         casPair(current, Pair.of(newReference, newStamp)));
}
// 如果在这之前已经有线程对pair进行更新，则会执行失败
private boolean casPair(Pair<V> cmp, Pair<V> val) {
    return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}
public V getRerference();
public int getStamp();
public void set(V newReference,int newStamp);