private static final Unsafe theUnsafe;

private Unsafe() {
}

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

Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafeField.setAccessible(true);
Unsafe unsafe = (Unsafe) theUnsafeField.get(null);
System.out.println(unsafe);

//分配內(nèi)存, 相當(dāng)于C++的malloc函數(shù)
public native long allocateMemory(long bytes);
//擴(kuò)充內(nèi)存
public native long reallocateMemory(long address, long bytes);
//釋放內(nèi)存
public native void freeMemory(long address);
//在給定的內(nèi)存塊中設(shè)置值
public native void setMemory(Object o, long offset, long bytes, byte value);
//內(nèi)存拷貝
public native void copyMemory(Object srcBase, long srcOffset, Object destBase, long destOffset, long bytes);
//獲取給定地址值，忽略修飾限定符的訪問(wèn)限制。與此類似操作還有: getInt，getDouble，getLong，getChar等
public native Object getObject(Object o, long offset);
//為給定地址設(shè)置值，忽略修飾限定符的訪問(wèn)限制，與此類似操作還有: putInt,putDouble，putLong，putChar等
public native void putObject(Object o, long offset, Object x);
//獲取給定地址的byte類型的值（當(dāng)且僅當(dāng)該內(nèi)存地址為allocateMemory分配時(shí)，此方法結(jié)果為確定的）
public native byte getByte(long address);
//為給定地址設(shè)置byte類型的值（當(dāng)且僅當(dāng)該內(nèi)存地址為allocateMemory分配時(shí)，此方法結(jié)果才是確定的）
public native void putByte(long address, byte x);

DirectByteBuffer(int cap) {                   // package-private

  super(-1, 0, cap, cap);
  boolean pa = VM.isDirectMemoryPageAligned();
  int ps = Bits.pageSize();
  long size = Math.max(1L, (long)cap + (pa ? ps : 0));
  Bits.reserveMemory(size, cap);

  long base = 0;
  try {
    //分配內(nèi)存，返回基地址
    base = unsafe.allocateMemory(size);
  } catch (OutOfMemoryError x) {
    Bits.unreserveMemory(size, cap);
    throw x;
  }
  //內(nèi)存初始化
  unsafe.setMemory(base, size, (byte) 0);
  if (pa && (base % ps != 0)) {
    // Round up to page boundary
    address = base + ps - (base & (ps - 1));
  } else {
    address = base;
  }
  //跟蹤directbytebuffer 對(duì)象的垃圾回收，實(shí)現(xiàn)堆外內(nèi)存的釋放
  cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
  att = null;
}

public class Cleaner extends PhantomReference<Object> {
  
   public static Cleaner create(Object var0, Runnable var1) {
        return var1 == null ? null : add(new Cleaner(var0, var1));
    }
}

package com.rickiyang.learn.javaagent;

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.reflect.Field;


/**
 * @author rickiyang
 * @date 2019-08-08
 * @Desc
 */
public class TestPhantomReference {
  public static boolean isRun = true;

  public static void main(String[] args) throws Exception {
    String str = new String("123");
    System.out.println(str.getClass() + "@" + str.hashCode());
    final ReferenceQueue<String> referenceQueue = new ReferenceQueue<>();
    new Thread(() -> {
      while (isRun) {
        Object obj = referenceQueue.poll();
        if (obj != null) {
          try {
            Field rereferent = Reference.class.getDeclaredField("referent");
            rereferent.setAccessible(true);
            Object result = rereferent.get(obj);
            System.out.println("gc will collect："
                               + result.getClass() + "@"
                               + result.hashCode() + "\t"
                               + result);
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
      }
    }).start();
    PhantomReference<String> weakRef = new PhantomReference<>(str, referenceQueue);
    str = null;
    Thread.currentThread().sleep(2000);
    System.gc();
    Thread.currentThread().sleep(2000);
    isRun = false;
  }
}

public void clean() {
  if (remove(this)) {
    try {
      this.thunk.run();
    } catch (final Throwable var2) {
      AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
          if (System.err != null) {
            (new Error("Cleaner terminated abnormally", var2)).printStackTrace();
          }

          System.exit(1);
          return null;
        }
      });
    }

  }
}

private static class Deallocator
        implements Runnable
    {

        private static Unsafe unsafe = Unsafe.getUnsafe();

       //省略無(wú)關(guān) 代碼
        public void run() {
            if (address == 0) {
                // Paranoia
                return;
            }
            unsafe.freeMemory(address);
            address = 0;
            Bits.unreserveMemory(size, capacity);
        }

    }

static {
  ThreadGroup tg = Thread.currentThread().getThreadGroup();
  for (ThreadGroup tgn = tg;
       tgn != null;
       tg = tgn, tgn = tg.getParent());
  Thread handler = new ReferenceHandler(tg, "Reference Handler");
  /* If there were a special system-only priority greater than
         * MAX_PRIORITY, it would be used here
         */
  handler.setPriority(Thread.MAX_PRIORITY);
  handler.setDaemon(true);
  handler.start();

  // provide access in SharedSecrets
  SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
    @Override
    public boolean tryHandlePendingReference() {
      return tryHandlePending(false);
    }
  });
}


static boolean tryHandlePending(boolean waitForNotify) {
  Reference<Object> r;
  Cleaner c;
  try {
    synchronized (lock) {
      if (pending != null) {
        r = pending;
        //如果當(dāng)前Reference對(duì)象是Cleaner類型的就進(jìn)行特殊處理
        c = r instanceof Cleaner ? (Cleaner) r : null;
        // unlink 'r' from 'pending' chain
        pending = r.discovered;
        r.discovered = null;
      } else {
        // The waiting on the lock may cause an OutOfMemoryError
        // because it may try to allocate exception objects.
        if (waitForNotify) {
          lock.wait();
        }
        // retry if waited
        return waitForNotify;
      }
    }
  } catch (OutOfMemoryError x) {
    Thread.yield();
    // retry
    return true;
  } catch (InterruptedException x) {
    // retry
    return true;
  }

  // clean 不為空的時(shí)候，走清理的邏輯
  if (c != null) {
    c.clean();
    return true;
  }

  ReferenceQueue<? super Object> q = r.queue;
  if (q != ReferenceQueue.NULL) q.enqueue(r);
  return true;
}

//讀屏障，禁止load操作重排序。屏障前的load操作不能被重排序到屏障后，屏障后的load操作不能被重排序到屏障前
public native void loadFence();
//寫屏障，禁止store操作重排序。屏障前的store操作不能被重排序到屏障后，屏障后的store操作不能被重排序到屏障前
public native void storeFence();
//全能屏障，禁止load、store操作重排序
public native void fullFence();

//返回系統(tǒng)指針的大小。返回值為4（32位系統(tǒng)）或 8（64位系統(tǒng)）。
public native int addressSize();  
//內(nèi)存頁(yè)的大小，此值為2的冪次方。
public native int pageSize();

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

    //通過(guò)allocateInstance創(chuàng)建對(duì)象,為其分配內(nèi)存地址，不會(huì)加載構(gòu)造函數(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");

    // 獲取實(shí)例域name和age在對(duì)象內(nèi)存中的偏移量并設(shè)置值
    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));
    // 設(shè)置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));
}

結(jié)果：
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);
            }
        }
        //如果有繼承父類的話，父類中的屬性也是要計(jì)算的
        c = c.getSuperclass();
    }
    //計(jì)算每個(gè)字段的偏移量，因?yàn)榈谝粋€(gè)字段的偏移量即在對(duì)象頭的基礎(chǔ)上偏移的
    //所以只需要比較當(dāng)前偏移量最大的字段即表示這是該對(duì)象最后一個(gè)字段的位置
    long maxSize = 0;
    for (Field f : fields) {
        long offset = unsafe.objectFieldOffset(f);
        if (offset > maxSize) {
            maxSize = offset;
        }
    }
    //上面計(jì)算的是對(duì)象最后一個(gè)字段的偏移量起始位置，java中對(duì)象最大長(zhǎng)度是8個(gè)字節(jié)(long)
    //這里的計(jì)算方式是 將 當(dāng)前偏移量 / 8 + 8字節(jié) 的padding
    return ((maxSize/8) + 1) * 8;
}

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

//返回?cái)?shù)組中第一個(gè)元素的偏移地址
public native int arrayBaseOffset(Class<?> arrayClass);
//返回?cái)?shù)組中一個(gè)元素占用的大小
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新增，給定對(duì)象o，根據(jù)獲取內(nèi)存偏移量指向的字段，將其增加delta，
 //這是一個(gè)CAS操作過(guò)程，直到設(shè)置成功方能退出循環(huán)，返回舊值
 public final int getAndAddInt(Object o, long offset, int delta) {
     int v;
     do {
         //獲取內(nèi)存中最新值
         v = getIntVolatile(o, offset);
       //通過(guò)CAS操作
     } while (!compareAndSwapInt(o, offset, v, v + delta));
     return v;
 }

//1.8新增，方法作用同上，只不過(guò)這里操作的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新增，給定對(duì)象o，根據(jù)獲取內(nèi)存偏移量對(duì)于字段，將其 設(shè)置為新值newValue，
 //這是一個(gè)CAS操作過(guò)程，直到設(shè)置成功方能退出循環(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;
 }