CAS原理

最新推荐文章于 2022-03-04 11:09:44 发布

Cessi

最新推荐文章于 2022-03-04 11:09:44 发布

阅读量122

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_31359953/article/details/107881995

版权

Java基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

CAS（compare-and-Swap）简介

比较替换，是一种实现并发算法的常用技术

其核心是Usafe类，内部的方法都是native方法，这些方法可以直接操作内存中的数据，访问系统底层。

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); }
    }
//...

    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

}

CAS底层原理

java.util.concurrent包完全建立在CAS上，CAS的核心是比较交换，首先给出一个期望值A，修改值B，然后比较当前内存的值V，当A==V，就赋值，否则就返回false。

Usafe底层是由内联函数（插入汇编）编写的，首先判断当前是否为多核处理器，如果是则加锁，比较操作为原子操作。

变量valueOffset，该变量在内存中的偏移地址，Unsafe通过内存偏移地址来获取数据

value使用volatile修饰，设置了多线程的可见性

分析一下自增代码，调用的最后还是compareAndSwapInt

public final int getAndIncrement() {
   return unsafe.getAndAddInt(this, valueOffset, 1);
}    

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;
   }
}

C++实现如下

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  oop p = JNIHandles::resolve(obj);
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

unsigned Atomic::cmpxchg(unsigned int exchange_value,
                         volatile unsigned int* dest, unsigned int compare_value) {
  assert(sizeof(unsigned int) == sizeof(jint), "more work to do");
  return (unsigned int)Atomic::cmpxchg((jint)exchange_value, (volatile jint*)dest,
                                       (jint)compare_value);
}

linux实现

inline jint Atomic::cmpxchg(jint exchange_value, volatile jint* dest, jint compare_value) {
  int mp = os::is_MP();
  __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;
}