Map大家族的那點事兒（五）WeakHashMap

改變ing發表於2018-09-07
HashMap

參考：https://sylvanassun.github.io/2018/03/16/2018-03-16-map_family/

 

      WeakHashMap是一個基於Map介面實現的雜湊表，實現細節與HashMap類似（都有負載因子、雜湊函式等等，但沒有HashMap那麼多優化手段），它的特殊之處在於每個key都是一個弱引用。

首先我們要明白什麼是弱引用，Java將引用分為四類（從JDK1.2開始），強度依次逐漸減弱：

  • 強引用： 就是平常使用的普通引用物件，例如Object obj = new Object()，這就是一個強引用，強引用只要還存在，就不會被垃圾收集器回收。

  • 軟引用： 軟引用表示一個還有用但並非必需的物件，不像強引用，它還需要通過SoftReference類來間接引用目標物件（除了強引用都是如此）。被軟引用關聯的物件，在將要發生記憶體溢位異常之前，會被放入回收範圍之中以進行第二次回收（如果第二次回收之後依舊沒有足夠的記憶體，那麼就會丟擲OOM異常）。

  • 弱引用： 同樣是表示一個非必需的物件，但要比軟引用的強度還要弱，需要通過WeakReference類來間接引用目標物件。被弱引用關聯的物件只能存活到下一次垃圾回收發生之前，當觸發垃圾回收時，無論當前記憶體是否足夠，都會回收掉只被弱引用關聯的物件（如果這個物件還被強引用所引用，那麼就不會被回收）。

  • 虛引用： 這是一種最弱的引用關係，需要通過PhantomReference類來間接引用目標物件。一個物件是否有虛引用的存在，完全不會對其生存時間構成影響，也無法通過虛引用來獲得物件例項。虛引用的唯一作用就是能在這個物件被回收時收到一個系統通知（結合ReferenceQueue使用）。基於這點可以通過虛引用來實現物件的解構函式，這比使用finalize()函式是要靠譜多了。

       WeakHashMap適合用來當做一個快取來使用。假設你的快取系統是基於強引用實現的，那麼你就必須以手動（或者用一條執行緒來不斷輪詢）的方式來刪除一個無效的快取項，而基於弱引用實現的快取項只要沒被其他強引用物件關聯，就會被直接放入回收佇列。

        需要注意的是，只有key是被弱引用關聯的，而value一般都是一個強引用物件。因此，需要確保value沒有關聯到它的key，否則會對key的回收產生阻礙。在極端的情況下，一個value物件A引用了另一個key物件D，而與D相對應的value物件C又反過來引用了與A相對應的key物件B，這就會產生一個引用迴圈，導致D與B都無法被正常回收。想要解決這個問題，就只能把value也變成一個弱引用，例如m.put(key, new WeakReference(value))，弱引用之間的互相引用不會產生影響。

    查詢操作的實現跟HashMap相比簡單了許多，只要讀懂了HashMap，基本都能看懂，原始碼如下：

/**
* Value representing null keys inside tables.
*/
private static final Object NULL_KEY = new Object();
/**
* Use NULL_KEY for key if it is null.
*/
private static Object maskNull(Object key) {
    return (key == null) ? NULL_KEY : key;
}
/**
* Returns index for hash code h.
*/
private static int indexFor(int h, int length) {
    return h & (length-1);
}
public V get(Object key) {
    // WeakHashMap允許null key與null value
    // null key會被替換為一個虛擬值
    Object k = maskNull(key);
    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;
}

       儘管key是一個弱引用，但仍需手動地回收那些已經無效的Entry。這個操作會在getTable()函式中執行，不管是查詢、新增還是刪除，都需要呼叫getTable()來獲得buckets陣列，所以這是種防止記憶體洩漏的被動保護措施。

/**
* The table, resized as necessary. Length MUST Always be a power of two.
*/
Entry<K,V>[] table;
/**
* Reference queue for cleared WeakEntries
*/
private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
/**
* Expunges stale entries from the table.
*/
private void expungeStaleEntries() {
    // 遍歷ReferenceQueue，然後清理table中無效的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);
            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;
            }
        }
    }
}
/**
* Returns the table after first expunging stale entries.
*/
private Entry<K,V>[] getTable() {
    expungeStaleEntries();
    return table;
}

   然後是插入操作與刪除操作，實現都比較簡單：

public V put(K key, V value) {
    Object k = maskNull(key);
    int h = hash(k);
    Entry<K,V>[] tab = getTable();
    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];
    // e被連線在new Entry的後面
    tab[i] = new Entry<>(k, value, queue, h, e);
    if (++size >= threshold)
    resize(tab.length * 2);
    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);
    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;
}

       我們並沒有在put()函式中發現key被轉換成弱引用，這是怎麼回事？key只有在第一次被放入buckets陣列時才需要轉換成弱引用，也就是new Entry<>(k, value, queue, h, e)，WeakHashMap的Entry實現其實就是WeakReference的子類。

/**
* The entries in this hash table extend WeakReference, using its main ref
* field as the key.
*/
private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
    V value;
    final int hash;
    Entry<K,V> next;
    /**
* Creates new entry.
*/
    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;
    }
    @SuppressWarnings("unchecked")
    public K getKey() {
        return (K) WeakHashMap.unmaskNull(get());
    }
    public V getValue() {
        return value;
    }
    public V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }
    public Boolean equals(Object o) {
        if (!(o instanceof Map.Entry))
        return false;
        Map.Entry<?,?> e = (Map.Entry<?,?>)o;
        K k1 = getKey();
        Object k2 = e.getKey();
        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
            V v1 = getValue();
            Object v2 = e.getValue();
            if (v1 == v2 || (v1 != null && v1.equals(v2)))
            return true;
        }
        return false;
    }
    public int hashCode() {
        K k = getKey();
        V v = getValue();
        return Objects.hashCode(k) ^ Objects.hashCode(v);
    }
    public String toString() {
        return getKey() + "=" + getValue();
    }
}

有關使用WeakReference的一個典型案例是ThreadLocal，感興趣的讀者可以參考我之前寫的部落格聊一聊Spring中的執行緒安全性。

相關文章