sun.misc.unsafe 的探究

参靠这里：  http://mishadoff.com/blog/java-magic-part-4-sun-dot-misc-dot-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 里面 还包含很多其他的方法的实现，就不再这里分析了