jdk 源码分析（10）java unsafe 分析

jdk里面原子操作unsafe都是native方法，看不到源代码，所以特意下载openjdk 9 的版本。

1）获取unsafe 对象，这个是openjdk里的方法。通过反射获得。

   static {
        Reflection.registerMethodsToFilter(Unsafe.class, "getUnsafe");
    }

    @CallerSensitive
    public static Unsafe getUnsafe() {
        Class<?> caller = Reflection.getCallerClass();
        if (!VM.isSystemDomainLoader(caller.getClassLoader()))
            throw new SecurityException("Unsafe");
        return theUnsafe;
    }

所以需要使用时直接

private static final Unsafe unsafe = Unsafe.getUnsafe();

unsafe 对象主要包括1）内存管理

public native long allocateMemory(long var1);public native long reallocateMemory(long var1, long var3);public native void setMemory(Object var1, long var2, long var4, byte var6);

2）对象cas，这个是乐观锁，如果变量没有被其他线程改变的话。会一直尝试去修改变量。直到变成修改值。等会将分析一下源代码。c语言的。

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

这里的参数是，对象，偏移量，期望值，修改值。

获取偏移量的方法：

valueOffset = unsafe.objectFieldOffset    (AtomicBoolean.class.getDeclaredField("value"));

还有：

public native long staticFieldOffset(Field var1);public native long objectFieldOffset(Field var1);public native Object staticFieldBase(Field var1);

3）supportlock

public native void unpark(Object var1);public native void park(boolean var1, long var2);

park类似于wait，unpark类似于notify。

4）cas 源码分析

具体见unsafe.cpp (版本： openjdk 9 )

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSetInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x)) {
  oop p = JNIHandles::resolve(obj);
//获取对象的变量的地址
  jint* addr = (jint *)index_oop_from_field_offset_long(p, offset);
//调用Atomic操作
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
} UNSAFE_END

进入atomic.hpp,大意就是先去获取一次结果，如果结果和现在不同，就直接返回，因为有其他人修改了；否则会一直尝试去修改。直到成功。

inline jbyte Atomic::cmpxchg(jbyte exchange_value, volatile jbyte* dest,
                             jbyte compare_value, cmpxchg_memory_order order) {
  STATIC_ASSERT(sizeof(jbyte) == 1);
  volatile jint* dest_int =
      static_cast<volatile jint*>(align_ptr_down(dest, sizeof(jint)));
  size_t offset = pointer_delta(dest, dest_int, 1);
  jint cur = *dest_int;
  jbyte* cur_as_bytes = reinterpret_cast<jbyte*>(&cur);
  // current value may not be what we are looking for, so force it
  // to that value so the initial cmpxchg will fail if it is different
  cur_as_bytes[offset] = compare_value;
  // always execute a real cmpxchg so that we get the required memory
  // barriers even on initial failure
  do {
    // value to swap in matches current value ...
    jint new_value = cur;
    // ... except for the one jbyte we want to update
    reinterpret_cast<jbyte*>(&new_value)[offset] = exchange_value;
    jint res = cmpxchg(new_value, dest_int, cur, order);
    if (res == cur) break; // success
    // at least one jbyte in the jint changed value, so update
    // our view of the current jint
    cur = res;
    // if our jbyte is still as cur we loop and try again
  } while (cur_as_bytes[offset] == compare_value);
  return cur_as_bytes[offset];
}

unsafe.cpp 里面 还包含很多其他的方法的实现，就不再这里分析了。