public abstract class Reference<T> {
    private T referent;   //對(duì)應(yīng)的引用對(duì)象
    volatile ReferenceQueue<? super T> queue; //引用隊(duì)列，初始化的時(shí)候從外部傳入
    Reference next;  // 當(dāng)引用對(duì)象可達(dá)性發(fā)生變化的時(shí)候，next會(huì)指向當(dāng)前引用
    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 { }; //鎖對(duì)象，用來同步隊(duì)列操作
    private Lock lock = new Lock(); 
    private volatile Reference<? extends T> head = null; //頭結(jié)點(diǎn)
    private long queueLength = 0; //隊(duì)列長(zhǎng)度
}

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

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
  V value;          //存儲(chǔ)的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);   //這里的引用對(duì)象是key，跟蹤的是key對(duì)象的垃圾回收
  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); //從隊(duì)列中拿到entry，根據(jù)entry獲取entry鏈表在table中的索引
            Entry<K,V> prev = table[i]; //找到entry鏈表的頭結(jié)點(diǎn)
            Entry<K,V> p = prev;
            while (p != null) {
                Entry<K,V> next = p.next;
                if (p == e) {
                    if (prev == e)
                        table[i] = next; //找到對(duì)應(yīng)節(jié)點(diǎn)
                    else
                        prev.next = next;
                    e.value = null; // Help GC
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }
}