Object obj = new Object();
ReferenceQueue<Object> refQueue = new ReferenceQueue<>();
PhantomReference<Object> phantom = new PhantomReference<Object>(obj, refQueue);
ReferenceQueue

ReferenceQueue queue = new ReferenceQueue();

WeakReference reference = new WeakReference(new Object(), queue);
System.out.println(reference);
System.gc();

Reference reference1 = queue.remove();
System.out.println(reference1);

// 用于保存對象的引用，GC會根據不同Reference來特別對待
private T referent;
// 如果需要通知機制，則保存的對對應的隊列
ReferenceQueue<? super T> queue;
/* 這個用于實現(xiàn)一個單向循環(huán)鏈表，用以將保存需要由ReferenceHandler處理的引用 */
Reference next;

static private class Lock { };
// 鎖，用于同步pending隊列的進隊和出隊
private static Lock lock = new Lock();
// 此屬性保存一個PENDING的隊列，配合上述next一起使用
private static Reference pending = null;

// 此線程在靜態(tài)塊中啟動，即一旦使用了Reference，則會啟動該線程
private static class ReferenceHandler extends Thread {
  public void run() {
    for (;;) {

      Reference r;
      synchronized (lock) {
        if (pending != null) {
          r = pending;
          Reference rn = r.next;
          // 從pending中取下一個元素，如果后繼為空，則next指向自身   pending = (rn == r) ? null : rn;
          r.next = r;
        } else {
          try {
            // 沒有則等待，后續(xù)加入元素會調用lock.notify喚醒
            lock.wait();
          } catch (InterruptedException x) { }
          continue;
        }
      }
      // ...
      ReferenceQueue q = r.queue;
      // 如果該Reference注冊了對應的Queue，則加入到該Queue中
      if (q != ReferenceQueue.NULL) q.enqueue(r);
    }
  }
}

// 用于標識沒有注冊Queue
static ReferenceQueue NULL = new Null();
// 用于標識已經處于對應的Queue中
static ReferenceQueue ENQUEUED = new Null();

static private class Lock { };
/* 互斥鎖，用于同步ReferenceHandler的enqueue和用戶線程操作的remove和poll出隊操作 */
private Lock lock = new Lock();
// 隊列
private volatile Reference<? extends T> head = null;
// 隊列中的元素個數
private long queueLength = 0;

boolean enqueue(Reference<? extends T> r) {
  synchronized (r) {
    // 判斷是否已經入隊了
    if (r.queue == ENQUEUED) return false;
    synchronized (lock) {
      r.queue = ENQUEUED;
      // 單向循環(huán)
      r.next = (head == null) ? r : head;
      head = r;
      queueLength++;
      if (r instanceof FinalReference) {
        sun.misc.VM.addFinalRefCount(1);
      }
      // 通知當前掛起的線程（調用remove時有可能會掛起）
      lock.notifyAll();
      return true;
    }
  }
}

public Reference<? extends T> remove(long timeout)
  throws IllegalArgumentException, InterruptedException
{
  if (timeout < 0) {
    throw new IllegalArgumentException("Negative timeout value");
  }
  synchronized (lock) {
    // 從隊列中取出一個元素
    Reference<? extends T> r = reallyPoll();
    // 如果不為空，則直接返回
    if (r != null) return r;
    for (;;) {
      // 否則等待，由enqueue時notify喚醒
      lock.wait(timeout);
      r = reallyPoll();
      if (r != null) return r;
      if (timeout != 0) return null;
    }
  }
}

// 創(chuàng)建一個引用隊列
ReferenceQueue queue = new ReferenceQueue();

// 創(chuàng)建虛引用，此時狀態(tài)為Active，并且Reference.pending為空，當前Reference.queue = 上面創(chuàng)建的queue，并且next=null
WeakReference reference = new WeakReference(new Object(), queue);
System.out.println(reference);
// 當GC執(zhí)行后，由于是虛引用，所以回收該object對象，并且置于pending上，此時reference的狀態(tài)為PENDING
System.gc();

/* ReferenceHandler從pending中取下該元素，并且將該元素放入到queue中，此時Reference狀態(tài)為ENQUEUED，Reference.queue = ReferenceENQUEUED */

/* 當從queue里面取出該元素，則變?yōu)镮NACTIVE，Reference.queue = Reference.NULL */
Reference reference1 = queue.remove();
System.out.println(reference1);

// 外部WeakHashMap屬性
private final ReferenceQueue<Object> queue = new ReferenceQueue<>();

/* 這里采用了集成WeakReference而不是直接使用，是因為當被回收的時候，具體的Key是不知道的，這里需要往WeakReference額外加入一些屬性，以便在被回收后通知時，能夠定位到具體的Key/value */
private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
  // 這里屬性不能加入key，否則會導致存在強引用而不能被視為WeakReference回收掉
  V value;
  int hash;
  Entry<K,V> next;
  
  Entry(Object key, V value,
     ReferenceQueue<Object> queue,
     int hash, Entry<K,V> next) {
    super(key, queue);
    this.value = value;
    this.hash = hash;
    this.next = next;
  }
  // ...
}