Java CAS实现原理

Java提供了对CAS的支持。参考另一篇文章：https://lobin.iteye.com/blog/2325737

 

在JAVA中，Unsafe类针对CAS操作提供了3个方法：compareAndSwapInt、compareAndSwapLong、compareAndSwapObject，分别用于原子操作更新Java变量，第1个用于int类型，第2个用于long类型，第3个用于Object类型。这3个方法都是native方法。对应的本机实现分别为Unsafe_CompareAndSwapInt、Unsafe_CompareAndSwapLong、Unsafe_CompareAndSwapObject。参考hotspot\src\share\vm\prims\unsafe.cpp。

 

compareAndSwapInt方法定义如下：

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

compareAndSwapLong方法定义如下：

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

compareAndSwapObject方法定义如下：

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

这3个方法都有4个参数，第1个参数表示要更新的变量所对应的对象，第2个参数表示要更新的变量相对于变量所对应的对象的偏移位置，也就是相对于第1个参数的偏移位置，第3个变量表示期望值，也就是CAS操作中的expect值，第4个参数表示要更新的值，如果更新成功，变量的值更新为要更新的值，返回true，否则返回false。

 

对应到本机方法实现，方法函数多了两个参数env，unsafe，参考另一篇文章：https://lobin.iteye.com/admin/blogs/2312005.第一个参数是一个JNIEnv类型的指针，表示Java Runtime运行时环境，第2个参数表示Unsafe对象，通过该参数可以得到Unsafe Java对象对应的oop。

 

其中Unsafe_CompareAndSwapInt方法实现在hotspot\src\share\vm\prims\unsafe.cpp中，代码如下：

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

以上代码需要将宏展开，从代码上看，首先调用resolve函数根据obj（要更新的变量所对应的对象）得到对应的oop，然后调用index_oop_from_field_offset_long函数得到要更新的变量在内存中的地址，最后调用Atomic::cmpxchg函数执行CAS操作更新变量为x，x为要更新的值，e为期望值，在执行CAS操作是会比较实际值和e期望值是否相等，如果相等则更新。

 

 

Unsafe_CompareAndSwapLong方法实现在hotspot\src\share\vm\prims\unsafe.cpp中，代码如下：

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x))
  UnsafeWrapper("Unsafe_CompareAndSwapLong");
  Handle p (THREAD, JNIHandles::resolve(obj));
  jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
  if (VM_Version::supports_cx8())
    return (jlong)(Atomic::cmpxchg(x, addr, e)) == e;
  else {
    jboolean success = false;
    ObjectLocker ol(p, THREAD);
    if (*addr == e) { *addr = x; success = true; }
    return success;
  }
UNSAFE_END

Unsafe_CompareAndSwapLong方法和Unsafe_CompareAndSwapInt方法总体上差不多，这里会检查JVM是否支持cmpxchg8，参考hotspot\src\share\vm\runtime\vm_version.hpp中的以下代码

// does HW support an 8-byte compare-exchange operation?
static bool supports_cx8()  
{
    return _supports_cx8;
}

在hotspot\src\cpu\x86\vm\vm_version_x86.cpp中的VM_Version::get_processor_features方法会检查JVM是否支持cmpxchg8：

void VM_Version::get_processor_features() {
    ... 
    ...
    _supports_cx8 = supports_cmpxchg8();
    ...
    ...
}

如果支持cmpxchg8的话，调用Atomic::cmpxchg函数执行CAS操作。否则的话就加锁，软件实现CAS操作。

 

Unsafe_CompareAndSwapObject方法实现在hotspot\src\share\vm\prims\unsafe.cpp中，代码如下：

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

Unsafe_CompareAndSwapObject方法和上面的两个方法不一样，这里调用的是oopDesc::atomic_compare_exchange_oop函数执行CAS操作更新。

 

JVM Atomic Atomic::cmpxchg：

 

CAS操作更新byte类型

参考hotspot\src\share\vm\runtime\atomic.cpp中的代码：

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;
  jbyte* cur_as_bytes = (jbyte*)(&cur);
  jint new_val = cur;
  jbyte* new_val_as_bytes = (jbyte*)(&new_val);
  new_val_as_bytes[offset] = exchange_value;
  while (cur_as_bytes[offset] == compare_value) {
    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];
}

CAS操作

通过内嵌汇编的方式通过对应的汇编指令执行CAS操作。

 

这里定义了一个宏LOCK_IF_MP：

 

#define LOCK_IF_MP(mp) "cmp $0, " #mp "; je 1f; lock; 1: "

 

 

CAS操作更新int类型

参考hotspot\src\os_cpu\linux_x86\vm\atomic_linux_x86.inline.hpp中的代码：

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

这里通过内嵌汇编的方式通过cmpxchgl汇编指令执行CAS操作。内嵌的汇编指令展开后：

 

__asm__ volatile ("cmp $0, " #%4 "; je 1f; lock; 1: " "cmpxchgl %1,(%3)"
                    : "=a" (exchange_value)
                    : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                    : "cc", "memory");

 

 

 

CAS操作更新long类型

参考hotspot\src\os_cpu\linux_x86\vm\atomic_linux_x86.inline.hpp中的代码：

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

这里通过内嵌汇编的方式通过cmpxchgq汇编指令执行CAS操作。内嵌的汇编指令展开后：

 

__asm__ __volatile__ ("cmp $0, " #%4 "; je 1f; lock; 1: " "cmpxchgq %1,(%3)"
                        : "=a" (exchange_value)
                        : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                        : "cc", "memory");

CAS操作更新oop类型，用于Java对象的CAS操作

参考hotspot\src\share\vm\oops\oop.inline.hpp中的代码：

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

这里如果Compressed，调用Atomic::cmpxchg函数执行CAS操作，参考另一篇文章：https://lobin.iteye.com/blog/2327905,narrowOop其实就是个无符号int类型，所以这里调用的是针对int类型的CAS操作更新。否则调用Atomic::cmpxchg_ptr函数执行CAS操作。

 

CAS操作更新指针类型

 

有两个方法，一个是针对void*类型的，一个是针对intptr_t类型的。参考hotspot\src\os_cpu\linux_x86\vm\atomic_linux_x86.inline.hpp中的代码：

void*类型

inline void*    Atomic::cmpxchg_ptr(void*    exchange_value, volatile void*     dest, void*    compare_value) {
  return (void*)cmpxchg((jlong)exchange_value, (volatile jlong*)dest, (jlong)compare_value);
}

 

intptr_t类型

在hotspot\src\share\vm\utilities\globalDefinitions_gcc.hpp中，intptr_t定义如下：

 

// %%%% how to access definition of intptr_t portably in 5.5 onward?
typedef int                     intptr_t;

在hotspot\src\share\vm\utilities\globalDefinitions_sparcWorks.hpp中，intptr_t定义如下：

 

 

// %%%% how to access definition of intptr_t portably in 5.5 onward?
typedef int                     intptr_t;

在hotspot\src\share\vm\utilities\globalDefinitions_visCPP.hpp中，intptr_t定义如下：

 

如果定义了_WIN64宏

 

typedef signed   __int64 intptr_t;

否则

 

 

typedef signed   int intptr_t;

所以这里针对intptr_t类型的cmpxchg_ptr实际上是int类型，但这个int类型应该表示的是一个地址

 

inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value) {
  return (intptr_t)cmpxchg((jlong)exchange_value, (volatile jlong*)dest, (jlong)compare_value);
}

这两种类型调用还是针对long类型的CAS操作更新。

 

1、https://docs.oracle.com/en/java

2、https://docs.oracle.com/javase/6/docs/

3、https://docs.oracle.com/en/java/javase/11/