private static int pageSize = -1;

static int pageSize() {
    if (pageSize == -1)
        pageSize = unsafe().pageSize();
    return pageSize;
}

// 終止掛起的線程，恢復正常.java.util.concurrent包中掛起操作都是在LockSupport類實現(xiàn)的，其底層正是使用這兩個方法
public native void unpark(Object thread);
// 線程調(diào)用該方法，線程將一直阻塞直到超時，或者是中斷條件出現(xiàn)。
public native void park(boolean isAbsolute, long time);
//獲得對象鎖（可重入鎖）
@Deprecated
public native void monitorEnter(Object o);
//釋放對象鎖
@Deprecated
public native void monitorExit(Object o);
//嘗試獲取對象鎖
@Deprecated
public native boolean tryMonitorEnter(Object o);

package leetcode;

import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.util.concurrent.TimeUnit;

/**
 * @author: rickiyang
 * @date: 2019/8/10
 * @description:
 */
public class TestUsafe {

    private static Thread mainThread;


    public Unsafe getUnsafe() throws Exception {
        Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafeField.setAccessible(true);
        return (Unsafe) theUnsafeField.get(null);
    }

    public void testPark() throws Exception {
        Unsafe unsafe = getUnsafe();
        mainThread = Thread.currentThread();

        System.out.println(String.format("park %s", mainThread.getName()));
        unsafe.park(false, TimeUnit.SECONDS.toNanos(3));

        new Thread(() -> {
            System.out.println(String.format("%s unpark %s", Thread.currentThread().getName(),
                                             mainThread.getName()));
            unsafe.unpark(mainThread);
        }).start();
        System.out.println("main thread is done");

    }

    public static void main(String[] args) throws Exception {
        TestUsafe testUsafe = new TestUsafe();
        testUsafe.testPark();
    }

}

// 傳入一個Class對象并創(chuàng)建該實例對象，但不會調(diào)用構造方法
public native Object allocateInstance(Class<?> cls) throws InstantiationException;

// 獲取字段f在實例對象中的偏移量
public native long objectFieldOffset(Field f);

// 返回值就是f.getDeclaringClass()
public native Object staticFieldBase(Field f);
// 靜態(tài)屬性的偏移量，用于在對應的Class對象中讀寫靜態(tài)屬性
public native long staticFieldOffset(Field f);

// 獲得給定對象偏移量上的int值，所謂的偏移量可以簡單理解為指針指向該變量；的內(nèi)存地址，
// 通過偏移量便可得到該對象的變量，進行各種操作
public native int getInt(Object o, long offset);
// 設置給定對象上偏移量的int值
public native void putInt(Object o, long offset, int x);

// 獲得給定對象偏移量上的引用類型的值
public native Object getObject(Object o, long offset);
// 設置給定對象偏移量上的引用類型的值
public native void putObject(Object o, long offset, Object x););

// 設置給定對象的int值，使用volatile語義，即設置后立馬更新到內(nèi)存對其他線程可見
public native void putIntVolatile(Object o, long offset, int x);
// 獲得給定對象的指定偏移量offset的int值，使用volatile語義，總能獲取到最新的int值。
public native int getIntVolatile(Object o, long offset);

// 與putIntVolatile一樣，但要求被操作字段必須有volatile修飾
public native void putOrderedInt(Object o, long offset, int x);

public class User {

    private String name;
    private int age;
    private static String address = "beijing";

    public User(){
        name = "xiaoming";
    }

    public String getname(){
        return name;
    }
}

	/**
     * 實例化對象
     * @throws Exception
     */
public void newInstance() throws Exception{
    TestUsafe testUsafe = new TestUsafe();
    Unsafe unsafe = testUsafe.getUnsafe();
    User user = new User();
    System.out.println(user.getname());

    User user1 = User.class.newInstance();
    System.out.println(user1.getname());

    User o = (User)unsafe.allocateInstance(User.class);
    System.out.println(o.getname());
}

public void testObject() throws Exception{
    TestUsafe testUsafe = new TestUsafe();
    Unsafe unsafe = testUsafe.getUnsafe();

    //通過allocateInstance創(chuàng)建對象,為其分配內(nèi)存地址，不會加載構造函數(shù)
    User user = (User) unsafe.allocateInstance(User.class);
    System.out.println(user);

    // Class && Field
    Class<? extends User> userClass = user.getClass();
    Field name = userClass.getDeclaredField("name");
    Field age = userClass.getDeclaredField("age");
    Field location = userClass.getDeclaredField("address");

    // 獲取實例域name和age在對象內(nèi)存中的偏移量并設置值
    System.out.println(unsafe.objectFieldOffset(name));
    unsafe.putObject(user, unsafe.objectFieldOffset(name), "xiaoming");
    System.out.println(unsafe.objectFieldOffset(age));
    unsafe.putInt(user, unsafe.objectFieldOffset(age), 18);
    System.out.println(user);

    // 獲取定義location字段的類
    Object staticFieldBase = unsafe.staticFieldBase(location);
    System.out.println(staticFieldBase);

    // 獲取static變量address的偏移量
    long staticFieldOffset = unsafe.staticFieldOffset(location);
    // 獲取static變量address的值
    System.out.println(unsafe.getObject(staticFieldBase, staticFieldOffset));
    // 設置static變量address的值
    unsafe.putObject(staticFieldBase, staticFieldOffset, "tianjin");
    System.out.println(user + " " + user.getAddress());
}

public class User {

    private String name;
    private int age;
}

TestUsafe testUsafe = new TestUsafe();
Unsafe unsafe = testUsafe.getUnsafe();

for (Field field : User.class.getDeclaredFields()) {
    System.out.println(field.getName() + "-" + field.getType() + ": " + unsafe.objectFieldOffset(field));
}

結果：
name-class java.lang.String: 16
age-int: 12

public static long sizeOf(Object o) throws Exception{
    TestUsafe testUsafe = new TestUsafe();
    Unsafe unsafe = testUsafe.getUnsafe();
    HashSet<Field> fields = new HashSet<Field>();
    Class c = o.getClass();
    while (c != Object.class) {
        for (Field f : c.getDeclaredFields()) {
            if ((f.getModifiers() & Modifier.STATIC) == 0) {
                fields.add(f);
            }
        }
        //如果有繼承父類的話，父類中的屬性也是要計算的
        c = c.getSuperclass();
    }
    //計算每個字段的偏移量，因為第一個字段的偏移量即在對象頭的基礎上偏移的
    //所以只需要比較當前偏移量最大的字段即表示這是該對象最后一個字段的位置
    long maxSize = 0;
    for (Field f : fields) {
        long offset = unsafe.objectFieldOffset(f);
        if (offset > maxSize) {
            maxSize = offset;
        }
    }
    //上面計算的是對象最后一個字段的偏移量起始位置，java中對象最大長度是8個字節(jié)(long)
    //這里的計算方式是 將 當前偏移量 / 8 + 8字節(jié) 的padding
    return ((maxSize/8) + 1) * 8;
}

//靜態(tài)屬性的偏移量，用于在對應的Class對象中讀寫靜態(tài)屬性
public native long staticFieldOffset(Field f);
//獲取一個靜態(tài)字段的對象指針
public native Object staticFieldBase(Field f);
//判斷是否需要初始化一個類，通常在獲取一個類的靜態(tài)屬性的時候（因為一個類如果沒初始化，它的靜態(tài)屬性也不會初始化）使用。 當且僅當ensureClassInitialized方法不生效時返回false
public native boolean shouldBeInitialized(Class<?> c);
//確保類被初始化
public native void ensureClassInitialized(Class<?> c);
//定義一個類，可用于動態(tài)創(chuàng)建類，此方法會跳過JVM的所有安全檢查，默認情況下，ClassLoader（類加載器）和ProtectionDomain（保護域）實例來源于調(diào)用者
public native Class<?> defineClass(String name, byte[] b, int off, int len,
                                   ClassLoader loader,
                                   ProtectionDomain protectionDomain);
//定義一個匿名類，可用于動態(tài)創(chuàng)建類
public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches);

//返回數(shù)組中第一個元素的偏移地址
public native int arrayBaseOffset(Class<?> arrayClass);
//返回數(shù)組中一個元素占用的大小
public native int arrayIndexScale(Class<?> arrayClass);

public final native boolean compareAndSwapObject(Object o, long offset,  Object expected, Object update);

public final native boolean compareAndSwapInt(Object o, long offset, int expected,int update);
  
public final native boolean compareAndSwapLong(Object o, long offset, long expected, long update);

//1.8新增，給定對象o，根據(jù)獲取內(nèi)存偏移量指向的字段，將其增加delta，
 //這是一個CAS操作過程，直到設置成功方能退出循環(huán)，返回舊值
 public final int getAndAddInt(Object o, long offset, int delta) {
     int v;
     do {
         //獲取內(nèi)存中最新值
         v = getIntVolatile(o, offset);
       //通過CAS操作
     } while (!compareAndSwapInt(o, offset, v, v + delta));
     return v;
 }

//1.8新增，方法作用同上，只不過這里操作的long類型數(shù)據(jù)
 public final long getAndAddLong(Object o, long offset, long delta) {
     long v;
     do {
         v = getLongVolatile(o, offset);
     } while (!compareAndSwapLong(o, offset, v, v + delta));
     return v;
 }

 //1.8新增，給定對象o，根據(jù)獲取內(nèi)存偏移量對于字段，將其 設置為新值newValue，
 //這是一個CAS操作過程，直到設置成功方能退出循環(huán)，返回舊值
 public final int getAndSetInt(Object o, long offset, int newValue) {
     int v;
     do {
         v = getIntVolatile(o, offset);
     } while (!compareAndSwapInt(o, offset, v, newValue));
     return v;
 }

// 1.8新增，同上，操作的是long類型
 public final long getAndSetLong(Object o, long offset, long newValue) {
     long v;
     do {
         v = getLongVolatile(o, offset);
     } while (!compareAndSwapLong(o, offset, v, newValue));
     return v;
 }

 //1.8新增，同上，操作的是引用類型數(shù)據(jù)
 public final Object getAndSetObject(Object o, long offset, Object newValue) {
     Object v;
     do {
         v = getObjectVolatile(o, offset);
     } while (!compareAndSwapObject(o, offset, v, newValue));
     return v;
 }