死磕 java集合之WeakHashMap源碼分析

簡介

WeakHashMap是一種弱引用map，內部的key會存儲爲弱引用，當jvm gc的時候，若是這些key沒有強引用存在的話，會被gc回收掉，下一次當咱們操做map的時候會把對應的Entry整個刪除掉，基於這種特性，WeakHashMap特別適用於緩存處理。

繼承體系

可見，WeakHashMap沒有實現Clone和Serializable接口，因此不具備克隆和序列化的特性。

存儲結構

WeakHashMap由於gc的時候會把沒有強引用的key回收掉，因此註定了它裏面的元素不會太多，所以也就不須要像HashMap那樣元素多的時候轉化爲紅黑樹來處理了。

所以，WeakHashMap的存儲結構只有（數組 + 鏈表）。

源碼解析

屬性

/**
 * 默認初始容量爲16
 */
private static final int DEFAULT_INITIAL_CAPACITY = 16;

/**
 * 最大容量爲2的30次方
 */
private static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * 默認裝載因子
 */
private static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
 * 桶
 */
Entry<K,V>[] table;

/**
 * 元素個數
 */
private int size;

/**
 * 擴容門檻，等於capacity * loadFactor
 */
private int threshold;

/**
 * 裝載因子
 */
private final float loadFactor;

/**
 * 引用隊列，當弱鍵失效的時候會把Entry添加到這個隊列中
 */
private final ReferenceQueue<Object> queue = new ReferenceQueue<>();

（1）容量

容量爲數組的長度，亦即桶的個數，默認爲16，最大爲2的30次方。

（2）裝載因子

裝載因子用來計算容量達到多少時才進行擴容，默認裝載因子爲0.75。

（3）引用隊列

當弱鍵失效的時候會把Entry添加到這個隊列中，當下次訪問map的時候會把失效的Entry清除掉。

Entry內部類

WeakHashMap內部的存儲節點, 沒有key屬性。

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
    // 能夠發現沒有key, 由於key是做爲弱引用存到Referen類中
    V value;
    final int hash;
    Entry<K,V> next;

    Entry(Object key, V value,
          ReferenceQueue<Object> queue,
          int hash, Entry<K,V> next) {
        // 調用WeakReference的構造方法初始化key和引用隊列
        super(key, queue);
        this.value = value;
        this.hash  = hash;
        this.next  = next;
    }
}

public class WeakReference<T> extends Reference<T> {
    public WeakReference(T referent, ReferenceQueue<? super T> q) {
        // 調用Reference的構造方法初始化key和引用隊列
        super(referent, q);
    }
}

public abstract class Reference<T> {
    // 實際存儲key的地方
    private T referent;         /* Treated specially by GC */
    // 引用隊列【本篇文章由公衆號「彤哥讀源碼」原創】
    volatile ReferenceQueue<? super T> queue;
    
    Reference(T referent, ReferenceQueue<? super T> queue) {
        this.referent = referent;
        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
    }
}

從Entry的構造方法咱們知道，key和queue最終會傳到到Reference的構造方法中，這裏的key就是Reference的referent屬性，它會被gc特殊對待，即當沒有強引用存在時，當下一次gc的時候會被清除。

構造方法

public WeakHashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Initial Capacity: "+
                initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;

    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal Load factor: "+
                loadFactor);
    int capacity = 1;
    while (capacity < initialCapacity)
        capacity <<= 1;
    table = newTable(capacity);
    this.loadFactor = loadFactor;
    threshold = (int)(capacity * loadFactor);
}

public WeakHashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

public WeakHashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}

public WeakHashMap(Map<? extends K, ? extends V> m) {
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
            DEFAULT_INITIAL_CAPACITY),
            DEFAULT_LOAD_FACTOR);
    putAll(m);
}

構造方法與HashMap基本相似，初始容量爲大於等於傳入容量最近的2的n次方，擴容門檻threshold等於capacity * loadFactor。

put(K key, V value)方法

添加元素的方法。

public V put(K key, V value) {
    // 若是key爲空，用空對象代替
    Object k = maskNull(key);
    // 計算key的hash值
    int h = hash(k);
    // 獲取桶
    Entry<K,V>[] tab = getTable();
    // 計算元素在哪一個桶中，h & (length-1)
    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;
        }
    }

    modCount++;
    // 若是沒找到就把新值插入到鏈表的頭部
    Entry<K,V> e = tab[i];
    tab[i] = new Entry<>(k, value, queue, h, e);
    // 若是插入元素後數量達到了擴容門檻就把桶的數量擴容爲2倍大小
    if (++size >= threshold)
        resize(tab.length * 2);
    return null;
}

（1）計算hash；

這裏與HashMap有所不一樣，HashMap中若是key爲空直接返回0，這裏是用空對象來計算的。

另外打散方式也不一樣，HashMap只用了一次異或，這裏用了四次，HashMap給出的解釋是一次夠了，並且就算衝突了也會轉換成紅黑樹，對效率沒什麼影響。

（2）計算在哪一個桶中；

（3）遍歷桶對應的鏈表；

（4）若是找到元素就用新值替換舊值，並返回舊值；

（5）若是沒找到就在鏈表頭部插入新元素；

HashMap就插入到鏈表尾部。

（6）若是元素數量達到了擴容門檻，就把容量擴大到2倍大小；

HashMap中是大於threshold才擴容，這裏等於threshold就開始擴容了。

resize(int newCapacity)方法

擴容方法。

void resize(int newCapacity) {
    // 獲取舊桶，getTable()的時候會剔除失效的Entry
    Entry<K,V>[] oldTable = getTable();
    // 舊容量
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }

    // 新桶
    Entry<K,V>[] newTable = newTable(newCapacity);
    // 把元素從舊桶轉移到新桶
    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 {
        // 不然把元素再轉移回舊桶，仍是使用舊桶
        // 由於在transfer的時候會清除失效的Entry，因此元素個數可能沒有那麼大了，就不須要擴容了
        expungeStaleEntries();
        transfer(newTable, oldTable);
        table = oldTable;
    }
}

private void transfer(Entry<K,V>[] src, Entry<K,V>[] dest) {
    // 遍歷舊桶
    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等於了null就清除，說明key被gc清理掉了，則把整個Entry清除
            if (key == null) {
                e.next = null;  // Help GC
                e.value = null; //  "   "
                size--;
            } else {
                // 不然就計算在新桶中的位置並把這個元素放在新桶對應鏈表的頭部
                int i = indexFor(e.hash, dest.length);
                e.next = dest[i];
                dest[i] = e;
            }
            e = next;
        }
    }
}

（1）判斷舊容量是否達到最大容量；

（2）新建新桶並把元素所有轉移到新桶中；

（3）若是轉移後元素個數不到擴容門檻的一半，則把元素再轉移回舊桶，繼續使用舊桶，說明不須要擴容；

（4）不然使用新桶，並計算新的擴容門檻；

（5）轉移元素的過程當中會把key爲null的元素清除掉，因此size會變小；

get(Object key)方法

獲取元素。

public V get(Object key) {
    Object k = maskNull(key);
    // 計算hash
    int h = hash(k);
    Entry<K,V>[] tab = getTable();
    int index = indexFor(h, tab.length);
    Entry<K,V> e = tab[index];
    // 遍歷鏈表，找到了就返回
    while (e != null) {
        if (e.hash == h && eq(k, e.get()))
            return e.value;
        e = e.next;
    }
    return null;
}

（1）計算hash值【本篇文章由公衆號「彤哥讀源碼」原創】；

（2）遍歷所在桶對應的鏈表；

（3）若是找到了就返回元素的value值；

（4）若是沒找到就返回空；

remove(Object key)方法

移除元素。

public V remove(Object key) {
    Object k = maskNull(key);
    // 計算hash
    int h = hash(k);
    Entry<K,V>[] tab = getTable();
    int i = indexFor(h, tab.length);
    // 元素所在的桶的第一個元素
    Entry<K,V> prev = tab[i];
    Entry<K,V> e = prev;

    // 遍歷鏈表
    while (e != null) {
        Entry<K,V> next = e.next;
        if (h == e.hash && eq(k, e.get())) {
            // 若是找到了就刪除元素
            modCount++;
            size--;

            if (prev == e)
                // 若是是頭節點，就把頭節點指向下一個節點
                tab[i] = next;
            else
                // 若是不是頭節點，刪除該節點
                prev.next = next;
            return e.value;
        }
        prev = e;
        e = next;
    }

    return null;
}

（1）計算hash；

（2）找到所在的桶；

（3）遍歷桶對應的鏈表；

（4）若是找到了就刪除該節點，並返回該節點的value值；

（5）若是沒找到就返回null；

expungeStaleEntries()方法

剔除失效的Entry。

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<K,V> prev = table[i];
            Entry<K,V> p = prev;
            // 遍歷鏈表
            while (p != null) {
                Entry<K,V> next = p.next;
                // 找到該元素
                if (p == e) {
                    // 刪除該元素
                    if (prev == e)
                        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;
                p = next;
            }
        }
    }
}

（1）當key失效的時候gc會自動把對應的Entry添加到這個引用隊列中；

（2）全部對map的操做都會直接或間接地調用到這個方法先移除失效的Entry，好比getTable()、size()、resize()；

（3）這個方法的目的就是遍歷引用隊列，並把其中保存的Entry從map中移除掉，具體的過程請看類註釋；

（4）從這裏能夠看到移除Entry的同時把value也一併置爲null幫助gc清理元素，防護性編程。

使用案例

說了這麼多，不舉個使用的例子怎麼過得去。

package com.coolcoding.code;

import java.util.Map;
import java.util.WeakHashMap;

public class WeakHashMapTest {

public static void main(String[] args) {
    Map<String, Integer> map = new WeakHashMap<>(3);

    // 放入3個new String()聲明的字符串
    map.put(new String("1"), 1);
    map.put(new String("2"), 2);
    map.put(new String("3"), 3);

    // 放入不用new String()聲明的字符串
    map.put("6", 6);

    // 使用key強引用"3"這個字符串
    String key = null;
    for (String s : map.keySet()) {
        // 這個"3"和new String("3")不是一個引用
        if (s.equals("3")) {
            key = s;
        }
    }

    // 輸出{6=6, 1=1, 2=2, 3=3}，未gc全部key均可以打印出來
    System.out.println(map);

    // gc一下
    System.gc();

    // 放一個new String()聲明的字符串
    map.put(new String("4"), 4);

    // 輸出{4=4, 6=6, 3=3}，gc後放入的值和強引用的key能夠打印出來
    System.out.println(map);

    // key與"3"的引用斷裂
    key = null;

    // gc一下【本篇文章由公衆號「彤哥讀源碼」原創】
    System.gc();

    // 輸出{6=6}，gc後強引用的key能夠打印出來
    System.out.println(map);
}
}

在這裏經過new String()聲明的變量纔是弱引用，使用"6"這種聲明方式會一直存在於常量池中，不會被清理，因此"6"這個元素會一直在map裏面，其它的元素隨着gc都會被清理掉。

總結

（1）WeakHashMap使用（數組 + 鏈表）存儲結構；

（2）WeakHashMap中的key是弱引用，gc的時候會被清除；

（3）每次對map的操做都會剔除失效key對應的Entry；

（4）使用String做爲key時，必定要使用new String()這樣的方式聲明key，纔會失效，其它的基本類型的包裝類型是同樣的；

（5）WeakHashMap經常使用來做爲緩存使用；

帶詳細註釋的源碼地址

WeakHashMap.java

彩蛋

強、軟、弱、虛引用知多少？

（1）強引用

使用最廣泛的引用。若是一個對象具備強引用，它絕對不會被gc回收。若是內存空間不足了，gc寧願拋出OutOfMemoryError，也不是會回收具備強引用的對象。

（2）軟引用

若是一個對象只具備軟引用，則內存空間足夠時不會回收它，但內存空間不夠時就會回收這部分對象。只要這個具備軟引用對象沒有被回收，程序就能夠正常使用。

（3）弱引用

若是一個對象只具備弱引用，則無論內存空間夠不夠，當gc掃描到它時就會回收它。

（4）虛引用

若是一個對象只具備虛引用，那麼它就和沒有任何引用同樣，任什麼時候候均可能被gc回收。

軟（弱、虛）引用必須和一個引用隊列（ReferenceQueue）一塊兒使用，當gc回收這個軟（弱、虛）引用引用的對象時，會把這個軟（弱、虛）引用放到這個引用隊列中。

好比，上述的Entry是一個弱引用，它引用的對象是key，當key被回收時，Entry會被放到queue中。

---

歡迎關注個人公衆號「彤哥讀源碼」，查看更多源碼系列文章, 與彤哥一塊兒暢遊源碼的海洋。