CAS和hotspot源码

偏执的太偏执、 2022-10-10 09:43 188阅读 0赞

# 一、用AtomicInteger.addAndGet(int delta)为分析的切入点 #

/** * Atomically adds the given value to the current value. * 原子化的为当前变量添加一个增量delta 德尔塔为增量，比如原子性的添加1 * @param delta the value to add 需要增加的增量，比如1 * @return the updated value 返回的是增加之后的量，比如原来为12 增加1后返回为13 */
        // setup to use Unsafe.compareAndSwapInt for updates
        // 所有的原子操作会使用的哦Unsafe这个类，在包：sun.misc下面
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        public final int addAndGet(int delta) { 
            return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
        }

调用Unsafe.java中方法：

/** * this = var1指当前的类Unsafe * valueOffset = var2 内存偏移量，为了去oldvalue值 * delta = var4 值增量，比如+1 中的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; }

this.getIntVolatile(var1, var2) 和this.compareAndSwapInt(var1, var2, var5, var5 + var4) 均为native方法，需要看hotspot的源码才行。

# 二、this.getIntVolatile(var1, var2) #

从偏移量中先取出获取当前值

public native int getIntVolatile(Object var1, long var2);

这里先解释下volatile的作用： 参见[`https://blog.csdn.net/tigerjibo/article/details/7427366`][https_blog.csdn.net_tigerjibo_article_details_7427366]

# 三、this.compareAndSwapInt(var1, var2, var5, var5 + var4) #

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

调用unsafe.cpp的

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

调用Unsafe\_CompareAndSwapInt方法：

/** src/share/vm/prims/unsafe.cpp offset ： value偏移 e：getIntVolatile读到的最新值，也即期望值 x：要更新的值即v + delta的值 */
    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

调用Atomic::cmpxchg：

/** src/os_cpu/linux_x86/vm/atomic_linux_x86.hpp 比较dest处的值与compare_value值是否相等，相等则说明未被更改，则将新值exchange_value更新到dest，返回exchange_value */
    inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) { 
      int mp = os::is_MP();
      //asm ： assembly汇编
      // LOCK_IF_MP如果是多核则加锁MP(multi processor)
      // 硬件支持，完成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;
    }

src/os_cpu/linux_x86/vm/atomic_linux_x86.hpp
    判断处理器数量 > 0 时，执行lock指令，锁定总线，刷新数据到内存，使各处理器的缓存失效，保证目标值对其他线程立即可见+
    #define LOCK_IF_MP(mp) "cmp $0, " #mp "; je 1f; lock; 1: "

Intel手册对lock前缀指令保证：
    
    确保对内存的读改写操作原子执行
    禁止该指令与之前和之后的读或写指令重排序
    把写缓冲区中的所有数据刷新到内存中
    这三条足以同时满足volatile读和写内存的语义，所以说CAS同时满足了volatile的读写语义，这个语义作为CAS的充分条件，使得CAS原子操作在不加锁时能够保证变量的读写对其他线程立即可见。可以看到在多处理器系统上AtomicInteger的整个自增操作可能伴随着多次lock操作。do { } while() 循环可能非常耗时。CAS即是天使也是魔鬼
    ————————————————
    
    参考原文：https://blog.csdn.net/u013928208/article/details/109317172
    https://blog.csdn.net/killerofjava/article/details/114173767

[https_blog.csdn.net_tigerjibo_article_details_7427366]: https://blog.csdn.net/tigerjibo/article/details/7427366