static {
    //省略部分代碼...
    Thread handler = new ReferenceHandler(tg, "Reference Handler");
    handler.setPriority(Thread.MAX_PRIORITY);
    handler.setDaemon(true);
    handler.start();
    //省略部分代碼...
}

public void run() {
    //死循環(huán)，線程啟動后會一直運行
    while (true) {
        tryHandlePending(true);
    }
}

static boolean tryHandlePending(boolean waitForNotify) {
    Reference<Object> r;
    Cleaner c;
    try {
        synchronized (lock) {
            if (pending != null) {
                r = pending;
                //instanceof 可能會拋出OOME，所以在將r從pending鏈上斷開前，做這個處理
                c = r instanceof Cleaner ? (Cleaner) r : null;
                //將將r從pending鏈上斷開
                pending = r.discovered;
                r.discovered = null;
            } else {
                //等待CG后的通知
                if (waitForNotify) {
                    lock.wait();
                }
                //重試
                return waitForNotify;
            }
        }
    } catch (OutOfMemoryError x) {
        //當拋出OOME時，放棄CPU的運行時間，這樣有希望收回一些存活的引用并且GC能回收部分空間。同時能避免頻繁地自旋重試，導致連續(xù)的OOME異常
        Thread.yield();
        //重試
        return true;
    } catch (InterruptedException x) {
         //重試
        return true;
    }
    //如果是Cleaner類型的Reference調用其clean方法并退出
    if (c != null) {
        c.clean();
        return true;
    }
    ReferenceQueue<? super Object> q = r.queue;
    //如果Reference有注冊ReferenceQueue，則處理pending指向的Reference結點將其加入ReferenceQueue中
    if (q != ReferenceQueue.NULL) q.enqueue(r);
    return true;
}

/* Reference實例有四種內部的狀態(tài)
 * Active: 新創(chuàng)建Reference的實例其狀態(tài)為Active。當GC檢測到Reference引用的referent可達到狀態(tài)發(fā)生改變時，
 * 為改變Reference的狀態(tài)為Pending或Inactive。這個取決于創(chuàng)建Reference實例時是否注冊過ReferenceQueue。
 * 注冊過其狀態(tài)會轉換為Pending，同時GC會將其加入pending-Reference鏈表中，否則為轉換為Inactive狀態(tài)。
 * Pending: 代表Reference是pending-Reference鏈表的成員，等待ReferenceHandler線程調用Cleaner#clean
 * 或ReferenceQueue#enqueue操作。未注冊過ReferenceQueue的實例不會達到這個狀態(tài)
 * Enqueued: Reference實例成為其被創(chuàng)建時注冊過的ReferenceQueue的成員，代表已入隊列。當其從ReferenceQueue
 * 中移除后，其狀態(tài)會變?yōu)镮nactive。
 * Inactive: 什么也不會做，一旦處理該狀態(tài)，就不可再轉換。
 * 不同狀態(tài)時，Reference對應的queue與成員next變量值(next可理解為ReferenceQueue中的下個結點的引用)如下:
 * Active: queue為Reference實例被創(chuàng)建時注冊的ReferenceQueue，如果沒注冊為Null。此時，next為null，
 * Reference實例與queue真正產(chǎn)生關系。
 * Pending: queue為Reference實例被創(chuàng)建時注冊的ReferenceQueue。next為當前實例本身。
 * Enqueued: queue為ReferenceQueue.ENQUEUED代表當前實例已入隊列。next為queue中的下一實列結點，
 * 如果是queue尾部則為當前實例本身
 * Inactive: queue為ReferenceQueue.NULL，當前實例已從queue中移除與queue無關聯(lián)。next為當前實例本身。
 */
public abstract class Reference<T> {
// Reference 引用的對象
private T referent;
/* Reference注冊的queue用于ReferenceHandler線程入隊列處理與用戶線程取Reference處理。
 * 其取值會根據(jù)Reference不同狀態(tài)發(fā)生改變，具體取值見上面的分析
 */
volatile ReferenceQueue<? super T> queue;
// 可理解為注冊的queue中的下一個結點的引用。其取值會根據(jù)Reference不同狀態(tài)發(fā)生改變，具體取值見上面的分析
volatile Reference next;
/* 其由VM維護，取值會根據(jù)Reference不同狀態(tài)發(fā)生改變，
 * 狀態(tài)為active時，代表由GC維護的discovered-Reference鏈表的下個節(jié)點，如果是尾部則為當前實例本身
 * 狀態(tài)為pending時，代表pending-Reference的下個節(jié)點的引用。否則為null
 */
transient private Reference<T> discovered;
/* pending-Reference 鏈表頭指針，GC回收referent后會將Reference加pending-Reference鏈表。
 * 同時ReferenceHandler線程會獲取pending指針，不為空時Cleaner.clean()或入列queue。
 * pending-Reference會采用discovered引用接鏈表的下個節(jié)點。
 */
private static Reference<Object> pending = null;
// 可理解為注冊的queue中的下一個結點的引用。其取值會根據(jù)Reference不同狀態(tài)發(fā)生改變，具體取值見上面的分析
volatile Reference next;
//用于CG同步Reference成員變量值的對象。
static private class Lock { }
private static Lock lock = new Lock();
//省略部分代碼...
}

//構造函數(shù)，指定引用的對象referent
Reference(T referent) {
    this(referent, null);
}
//構造函數(shù)，指定引用的對象referent與注冊的queue
Reference(T referent, ReferenceQueue<? super T> queue) {
    this.referent = referent;
    this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}
//獲取引用的對象referent
public T get() {
    return this.referent;
}
//將當前對象加入創(chuàng)建時注冊的queue中
public boolean enqueue() {
    return this.queue.enqueue(this);
}

//代表Reference的queue為null。Null為ReferenceQueue子類
static ReferenceQueue<Object> NULL = new Null<>();
//代表Reference已加入當前ReferenceQueue中。
static ReferenceQueue<Object> ENQUEUED = new Null<>();
//用于同步的對象
private Lock lock = new Lock();
//當前ReferenceQueue中的頭節(jié)點
private volatile Reference<? extends T> head = null;
//ReferenceQueue的長度
private long queueLength = 0;

//入列隊enqueue方法，只被Reference類調用，也就是上面分析中ReferenceHandler線程為調用
boolean enqueue(Reference<? extends T> r) {
	//獲取同步對象lock對應的監(jiān)視器對象
    synchronized (lock) {
        //獲取r關聯(lián)的ReferenceQueue，如果創(chuàng)建r時未注冊ReferenceQueue則為NULL，同樣如果r已從ReferenceQueue中移除其也為null
        ReferenceQueue<?> queue = r.queue;
        //判斷queue是否為NULL 或者 r已加入ReferenceQueue中，是的話則入隊列失敗
        if ((queue == NULL) || (queue == ENQUEUED)) {
            return false;
        }
        assert queue == this;
        //設置r的queue為已入隊列
        r.queue = ENQUEUED;
        //如果ReferenceQueue頭節(jié)點為null則r的next節(jié)點指向當前節(jié)點，否則指向頭節(jié)點
        r.next = (head == null) ? r : head;
        //更新ReferenceQueue頭節(jié)點
        head = r;
        //列隊長度加1
        queueLength++;
        //為FinalReference類型引用增加FinalRefCount數(shù)量
        if (r instanceof FinalReference) {
            sun.misc.VM.addFinalRefCount(1);
        }
        //通知remove操作隊列有節(jié)點
        lock.notifyAll();
        return true;
    }
}

public Reference<? extends T> poll() {
    //頭結點為null直接返回，代表Reference還沒有加入ReferenceQueue中
    if (head == null)
        return null;
    //獲取同步對象lock對應的監(jiān)視器對象
    synchronized (lock) {
        return reallyPoll();
    }
}
//從隊列中真正poll元素的方法
private Reference<? extends T> reallyPoll() {
    Reference<? extends T> r = head;
    //double check 頭節(jié)點不為null
    if (r != null) {
    	//保存頭節(jié)點的下個節(jié)點引用
        Reference<? extends T> rn = r.next;
        //更新queue頭節(jié)點引用
        head = (rn == r) ? null : rn;
        //更新Reference的queue值，代表r已從隊列中移除
		r.queue = NULL;
		//更新Reference的next為其本身
        r.next = r;
        queueLength--;
        //為FinalReference節(jié)點FinalRefCount數(shù)量減1
        if (r instanceof FinalReference) {
            sun.misc.VM.addFinalRefCount(-1);
        }
        //返回獲取的節(jié)點
        return r;
    }
    return null;
}

public Reference<? extends T> remove(long timeout) throws IllegalArgumentException, InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("Negative timeout value");
    }
    //獲取同步對象lock對應的監(jiān)視器對象
    synchronized (lock) {
    	//獲取隊列頭節(jié)點指向的Reference
        Reference<? extends T> r = reallyPoll();
        //獲取到返回
        if (r != null) return r;
        long start = (timeout == 0) ? 0 : System.nanoTime();
        //在timeout時間內嘗試重試獲取
        for (;;) {
        	//等待隊列上有結點通知
            lock.wait(timeout);
            //獲取隊列中的頭節(jié)點指向的Reference
            r = reallyPoll();
            //獲取到返回
            if (r != null) return r;
            if (timeout != 0) {
                long end = System.nanoTime();
                timeout -= (end - start) / 1000_000;
                //已超時但還沒有獲取到隊列中的頭節(jié)點指向的Reference返回null
                if (timeout <= 0) return null;
                start = end;
            }
        }
    }
}

//繼承了PhantomReference類也就是虛引用，PhantomReference源碼很簡單只是重寫了get方法返回null
public class Cleaner extends PhantomReference<Object> {
	/* 虛隊列，命名很到位。之前說CG把ReferenceQueue加入pending-Reference鏈中后，ReferenceHandler線程在處理時
     * 是不會將對應的Reference加入列隊的，而是調用Cleaner.clean方法。但如果Reference不注冊ReferenceQueue，GC處理時
     * 又無法把他加入到pending-Reference鏈中，所以Cleaner里面有了一個dummyQueue成員變量。
     */
    private static final ReferenceQueue<Object> dummyQueue = new ReferenceQueue();
    //Cleaner鏈表的頭結點
    private static Cleaner first = null;
    //當前Cleaner節(jié)點的后續(xù)節(jié)點
    private Cleaner next = null;
    //當前Cleaner節(jié)點的前續(xù)節(jié)點
    private Cleaner prev = null;
    //真正執(zhí)行清理工作的Runnable對象，實際clean內部調用thunk.run()方法
    private final Runnable thunk;
    //省略部分代碼...
}

//私有方法，不能直接new
private Cleaner(Object var1, Runnable var2) {
    super(var1, dummyQueue);
    this.thunk = var2;
}
//創(chuàng)建Cleaner對象，同時加入Cleaner鏈中。
public static Cleaner create(Object var0, Runnable var1) {
    return var1 == null ? null : add(new Cleaner(var0, var1));
}
//頭插法將新創(chuàng)意的Cleaner對象加入雙向鏈表，synchronized保證同步
private static synchronized Cleaner add(Cleaner var0) {
    if (first != null) {
        var0.next = first;
        first.prev = var0;
    }
    //更新頭節(jié)點引用
    first = var0;
    return var0;
}

public void clean() {
	//從Cleaner鏈表中先移除當前節(jié)點
    if (remove(this)) {
        try {
        	//調用thunk.run()方法執(zhí)行對應清理邏輯
            this.thunk.run();
        } catch (final Throwable var2) {
           //省略部分代碼..
        }

    }
}

public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}

DirectByteBuffer(int cap) {
    //省略部分代碼...
    try {
    	//調用unsafe分配內存
        base = unsafe.allocateMemory(size);
    } catch (OutOfMemoryError x) {
       //省略部分代碼...
    }
    //省略部分代碼...
    //前面分析中的Cleaner對象創(chuàng)建，持有當前DirectByteBuffer的引用
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;
}

public void run() {
    if (address == 0) {
        // Paranoia
        return;
    }
    //通過unsafe.freeMemory釋放創(chuàng)建的堆外內存
    unsafe.freeMemory(address);
    address = 0;
    Bits.unreserveMemory(size, capacity);
}

//Entry繼承了WeakReference, WeakReference引用的是Map的key
private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
    V value;
    final int hash;
    Entry<K,V> next;
    /**
     * 創(chuàng)建Entry對象，上面分析過的ReferenceQueue，這個queue實際是WeakHashMap的成員變量，
     * 創(chuàng)建WeakHashMap時其便被初始化 final ReferenceQueue<Object> queue = new ReferenceQueue<>()
     */
    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;
    }
    //省略部分原碼...
}

private void expungeStaleEntries() {
    //不斷地從ReferenceQueue中取出，那些只有被WeakReference對象引用的對象的Reference
    for (Object x; (x = queue.poll()) != null; ) {
        synchronized (queue) {
            //轉為 entry
            Entry<K,V> e = (Entry<K,V>) x;
            //計算其對應的桶的下標
            int i = indexFor(e.hash, table.length);
            //取出桶中元素
            Entry<K,V> prev = table[i];
            Entry<K,V> p = prev;
            //桶中對應位置有元素，遍歷桶鏈表所有元素
            while (p != null) {
                Entry<K,V> next = p.next;
                //如果當前元素(也就是entry)與queue取出的一致，將entry從鏈表中去除
                if (p == e) {
                    if (prev == e)
                        table[i] = next;
                    else
                        prev.next = next;
                    // Must not null out e.next;
                    //清空entry對應的value
                    e.value = null;
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }
}