public abstract class Reference<T> {
    private T referent;   //對應的引用對象
    volatile ReferenceQueue<? super T> queue; //引用隊列，初始化的時候從外部傳入
    Reference next;  // 當引用對象可達性發(fā)生變化的時候，next會指向當前引用
    transient private Reference<T> discovered;  /* used by VM */
    static private class Lock { } 
    private static Lock lock = new Lock(); //用來同步鎖操作
}

public class ReferenceQueue {
    static private class Lock { }; //鎖對象，用來同步隊列操作
    private Lock lock = new Lock(); 
    private volatile Reference<? extends T> head = null; //頭結點
    private long queueLength = 0; //隊列長度
}

boolean enqueue(Reference<? extends T> r) { /* Called only by Reference class */
   synchronized (lock) {
        ReferenceQueue<?> queue = r.queue; //獲取reference之前的隊列，如果沒有綁定隊列，那就不需要入隊
        if ((queue == NULL) || (queue == ENQUEUED)) {
            return false;
        }
        assert queue == this;
        r.queue = ENQUEUED;
        r.next = (head == null) ? r : head; //把r從鏈表的頭部插入
        head = r; //頭結點指向r
        queueLength++; //隊列長度+1
        if (r instanceof FinalReference) {
            sun.misc.VM.addFinalRefCount(1);
        }
        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; //獲取成功，返回
        long start = (timeout == 0) ? 0 : System.nanoTime(); //如果超時時間不為0，就記錄一下當前的開始時間
        for (;;) {
            lock.wait(timeout);
            r = reallyPoll();
            if (r != null) return r;
            if (timeout != 0) {
                long end = System.nanoTime();
                timeout -= (end - start) / 1000_000; //計算一下等待的時間
                if (timeout <= 0) return null; //確認等待是否是超時，如果是就返回，否則就認為是有入隊請求喚醒當前線程，但是當前線程嘗試刪除頭結點失敗了（被其他線程刪除了），那么繼續(xù)嘗試刪除頭結點，再次執(zhí)行循環(huán)中的內(nèi)容直到超時
                start = end;
            }
        }
    }
}

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
  V value;          //存儲的value    
  final int hash;   //hash值
  Entry<K,V> next;  //拉鏈法解決沖突，形成單鏈表
  Entry(Object key, V value,ReferenceQueue<Object> queue, int hash, Entry<K,V> next) {
  super(key, queue);   //這里的引用對象是key，跟蹤的是key對象的垃圾回收
  this.value = value;
  this.hash  = hash;
  this.next  = next;
  }
  ...
}

private void expungeStaleEntries() {
    for (Object x; (x = queue.poll()) != null; ) {
        synchronized (queue) {
            @SuppressWarnings("unchecked")
                Entry<K,V> e = (Entry<K,V>) x;
            int i = indexFor(e.hash, table.length); //從隊列中拿到entry，根據(jù)entry獲取entry鏈表在table中的索引
            Entry<K,V> prev = table[i]; //找到entry鏈表的頭結點
            Entry<K,V> p = prev;
            while (p != null) {
                Entry<K,V> next = p.next;
                if (p == e) {
                    if (prev == e)
                        table[i] = next; //找到對應節(jié)點
                    else
                        prev.next = next;
                    e.value = null; // Help GC
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }
}