1 java.lang.Object
2        java.util.AbstractMap<K, V>
3              java.util.WeakHashMap<K, V>
4 
5 public class WeakHashMap<K,V>
6     extends AbstractMap<K,V>
7     implements Map<K,V> {}

private static class ReferenceHandler extends Thread {
        private static void ensureClassInitialized(Class<?> clazz) {
            try {
                Class.forName(clazz.getName(), true, clazz.getClassLoader());
            } catch (ClassNotFoundException e) {
                throw (Error) new NoClassDefFoundError(e.getMessage()).initCause(e);
            }
        }
        static {
            // pre-load and initialize InterruptedException and Cleaner classes
            // so that we don't get into trouble later in the run loop if there's
            // memory shortage while loading/initializing them lazily.
            ensureClassInitialized(InterruptedException.class);
            ensureClassInitialized(Cleaner.class);
        }
        ReferenceHandler(ThreadGroup g, String name) {
            super(g, name);
        }
        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' might throw OutOfMemoryError sometimes
                    // so do this before un-linking 'r' from the 'pending' chain...
                    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) {
            // Give other threads CPU time so they hopefully drop some live references
            // and GC reclaims some space.
            // Also prevent CPU intensive spinning in case 'r instanceof Cleaner' above
            // persistently throws OOME for some time...
            Thread.yield();
            // retry
            return true;
        } catch (InterruptedException x) {
            // retry
            return true;
        }
        // Fast path for cleaners
        if (c != null) {
            c.clean();
            return true;
        }
        // 加入對列
        ReferenceQueue<? super Object> q = r.queue;
        if (q != ReferenceQueue.NULL) q.enqueue(r);
        return true;
    }
    static {
        ThreadGroup tg = Thread.currentThread().getThreadGroup();
        for (ThreadGroup tgn = tg;
             tgn != null;
             tg = tgn, tgn = tg.getParent());
        // 創(chuàng)建handler
        Thread handler = new ReferenceHandler(tg, "Reference Handler");
        /* If there were a special system-only priority greater than
         * MAX_PRIORITY, it would be used here
         */
        // 線程優(yōu)先級最大
        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);
            }
        });
    }

public V put(K key, V value) {
        // 確定key值，允許key為null
        Object k = maskNull(key);
        // 獲取器hash值
        int h = hash(k);
        // 獲取tab
        Entry<K,V>[] tab = getTable();
        // 確定在tab中的位置 簡單的&操作
        int i = indexFor(h, tab.length);
        // 遍歷，是否要進行覆蓋操作
        for (Entry<K,V> e = tab[i]; e != null; e = e.next) {
            if (h == e.hash && eq(k, e.get())) {
                V oldValue = e.value;
                if (value != oldValue)
                    e.value = value;
                return oldValue;
            }
        }
        // 修改次數(shù)自增
        modCount++;
        // 取出i上的元素
        Entry<K,V> e = tab[i];
        // 構建鏈表，新元素在鏈表頭
        tab[i] = new Entry<>(k, value, queue, h, e);
        // 檢查是否需要擴容
        if (++size >= threshold)
            resize(tab.length * 2);
        return null;
    }

public V get(Object key) {
        // 確定key
        Object k = maskNull(key);
        // 計算其hashCode
        int h = hash(k);
        Entry<K,V>[] tab = getTable();
        int index = indexFor(h, tab.length);
        // 獲取對應位置上的元素
        Entry<K,V> e = tab[index];
        while (e != null) {
            // 如果hashCode相同，并且key也相同，則返回，否則繼續(xù)循環(huán)
            if (e.hash == h && eq(k, e.get()))
                return e.value;
            e = e.next;
        }
        // 未找到，則返回null
        return null;
    }

public V remove(Object key) {
        Object k = maskNull(key);
        int h = hash(k);
        Entry<K,V>[] tab = getTable();
        int i = indexFor(h, tab.length);
        // 數(shù)組上第一個元素
        Entry<K,V> prev = tab[i];
        Entry<K,V> e = prev;
        // 循環(huán)
        while (e != null) {
            Entry<K,V> next = e.next;
            // 如果hash值相同，并且key一樣，則進行移除操作
            if (h == e.hash && eq(k, e.get())) {
                // 修改次數(shù)自增
                modCount++;
                // 元素個數(shù)自減
                size--;
                // 如果就是頭元素，則直接移除即可
                if (prev == e)
                    tab[i] = next;
                else
                    // 否則將前驅元素的next賦值為next，則將e移除
                    prev.next = next;
                return e.value;
            }
            // 更新prev和e，繼續(xù)循環(huán)
            prev = e;
            e = next;
        }
        return null;
    }

void resize(int newCapacity) {
    Entry<K,V>[] oldTable = getTable();
    // 原數(shù)組長度
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
    // 創(chuàng)建新的數(shù)組
    Entry<K,V>[] newTable = newTable(newCapacity);
    // 數(shù)據(jù)轉移
    transfer(oldTable, newTable);
    table = newTable;
    /*
     * If ignoring null elements and processing ref queue caused massive
     * shrinkage, then restore old table.  This should be rare, but avoids
     * unbounded expansion of garbage-filled tables.
     */
    // 確定擴容閾值
    if (size >= threshold / 2) {
        threshold = (int)(newCapacity * loadFactor);
    } else {
        // 清除被GC的value
        expungeStaleEntries();
        // 數(shù)組轉移
        transfer(newTable, oldTable);
        table = oldTable;
    }
}
 private void transfer(Entry<K,V>[] src, Entry<K,V>[] dest) {
    // 遍歷原數(shù)組
    for (int j = 0; j < src.length; ++j) {
        // 取出元素
        Entry<K,V> e = src[j];
        src[j] = null;
        // 鏈式找元素
        while (e != null) {
            Entry<K,V> next = e.next;
            Object key = e.get();
            // key被回收的情況
            if (key == null) {
                e.next = null;  // Help GC
                e.value = null; //  "   "
                size--;
            } else {
                // 確定在新數(shù)組的位置
                int i = indexFor(e.hash, dest.length);
                // 插入元素 注意這里為頭插法，會倒序
                e.next = dest[i];
                dest[i] = e;
            }
            e = next;
        }
    }
}

private void expungeStaleEntries() {
        // 從隊列中取出被GC的Entry
        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);
                // 取出數(shù)組中的第一個元素 prev
                Entry<K,V> prev = table[i];
                Entry<K,V> p = prev;
                // 循環(huán)
                while (p != null) {
                    Entry<K,V> next = p.next;
                    // 找到
                    if (p == e) {
                        // 判斷是否是鏈表頭元素 第一次時
                        if (prev == e)
                            // 將next直接掛在i位置
                            table[i] = next;
                        else
                            // 進行截斷
                            prev.next = next;
                        // Must not null out e.next;
                        // stale entries may be in use by a HashIterator
                        e.value = null; // Help GC
                        size--;
                        break;
                    }
                    // 更新prev和p
                    prev = p;
                    p = next;
                }
            }
        }
    }