Java CAS

2019-01-08  本文已影响0人  牛家彬

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当前所指向地址存的值返回。

上一篇下一篇

猜你喜欢

热点阅读