Java中WeakHashMap的弱鍵回收機制

更新時間：2023年09月07日 09:21:00 作者：Tony-老師

這篇文章主要介紹了Java中WeakHashMap的弱鍵回收機制,WeakHashMap繼承AbstractMap,實現(xiàn)了Map接口,和HashMap一樣,WeakHashMap也是一個散列表,它存儲的內(nèi)容也是鍵值對(key-value)映射,而且鍵和值都可以是null,需要的朋友可以參考下

1. WeakHashMap介紹

WeakHashMap繼承AbstractMap，實現(xiàn)了Map接口。

和HashMap一樣，WeakHashMap也是一個散列表，它存儲的內(nèi)容也是鍵值對(key-value)映射，而且鍵和值都可以是null。

不過WeakHashMap的鍵是"弱鍵"。在WeakHashMap中，當某個鍵不再正常使用時，會被從WeakHashMap中被自動移除。

更精確地說，對于一個給定的鍵，其映射的存在并不阻止垃圾回收器對該鍵的丟棄，這就使該鍵成為可終止的，被終止，然后被回收。某個鍵被終止時，它對應(yīng)的鍵值對也就從映射中有效地移除了。

WeakHashMap內(nèi)部是通過弱引用來管理 entry 的，弱引用的特性對應(yīng)到WeakHashMap上意味著什么呢？

將一對 key, value 放入到WeakHashMap里并不能避免該 key 值被GC回收，除非在WeakHashMap之外還有對該 key 的強引用。

和HashMap一樣，WeakHashMap是不同步的?？梢允褂肅ollections.synchronizedMap方法來構(gòu)造同步的WeakHashMap。

2. WeakHashMap例子

public class TestWeakHashMap {
    public static void main(String[] args) {
        WeakHashMap<String, String> weakHashMap = new WeakHashMap<>(10);
        String key0 = new String("kuang");
        String key1 = new String("zhong");
        String key2 = new String("wen");
        // 存放元素
        weakHashMap.put(key0, "q1");
        weakHashMap.put(key1, "q2");
        weakHashMap.put(key2, "q3");
        System.out.printf("weakHashMap: %s\n", weakHashMap);
        // 是否包含某key
        System.out.printf("contains key kuang : %s\n", weakHashMap.containsKey(key0));
        System.out.printf("contains key zhong : %s\n", weakHashMap.containsKey(key1));
        // 是否包含某value
        System.out.printf("contains value 0 : %s\n", weakHashMap.containsValue(0));
        // 移除key
        weakHashMap.remove(key2);
        System.out.printf("weakHashMap after remove: %s", weakHashMap);
        // 這意味著"弱鍵"key0再沒有被其它對象引用，調(diào)用gc時會回收WeakHashMap中與key0對應(yīng)的鍵值對
        key0 = null;
        // 內(nèi)存回收，這里會回收WeakHashMap中與"key0"對應(yīng)的鍵值對
        System.gc();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 遍歷WeakHashMap
        Iterator iter = weakHashMap.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry en = (Map.Entry) iter.next();
            System.out.printf("next : %s - %s\n", en.getKey(), en.getValue());
        }
        // 打印WeakHashMap的實際大小
        System.out.printf("after gc WeakHashMap size: %s\n", weakHashMap.size());
    }
}

執(zhí)行輸出：

weakHashMap: {wen=q3, zhong=q2, kuang=q1}
contains key kuang : true
contains key zhong : true
contains value 0 : false
weakHashMap after remove: {zhong=q2, kuang=q1}next : zhong - q2
after gc WeakHashMap size: 1

上面的例子展示了WeakHashMap的增刪改查，以及弱鍵的回收，可以看到把Key的引用置為null，gc后，會將該鍵值對回收。

3. WeakHashMap的使用場景

一般用做緩存，比如Tomcat的源碼里，實現(xiàn)緩存時會用到WeakHashMap，在緩存系統(tǒng)中，使用WeakHashMap可以避免內(nèi)存泄漏，但是使用WeakHashMap做緩存時要注意，如果只有它的key只有WeakHashMap本身在用，而在WeakHashMap之外沒有對該 key 的強引用，那么GC時會回收這個key對應(yīng)的entry。所以WeakHashMap不能用做主緩存，合適的用法應(yīng)該是用它做二級的內(nèi)存緩存，即那么過期緩存數(shù)據(jù)或者低頻緩存數(shù)據(jù)。

public final class ConcurrentCache<K,V> {
    private final int size;
    private final Map<K,V> eden;
    private final Map<K,V> longterm;
    public ConcurrentCache(int size) {
        this.size = size;
        this.eden = new ConcurrentHashMap<>(size);
        this.longterm = new WeakHashMap<>(size);
    }
    public V get(K k) {
        V v = this.eden.get(k);
        if (v == null) {
            synchronized (longterm) {
                v = this.longterm.get(k);
            }
            if (v != null) {
                this.eden.put(k, v);
            }
        }
        return v;
    }
    public void put(K k, V v) {
        if (this.eden.size() >= size) {
            synchronized (longterm) {
                this.longterm.putAll(this.eden);
            }
            this.eden.clear();
        }
        this.eden.put(k, v);
    }
}

源碼中有eden和longterm的兩個map，對jvm堆區(qū)有所了解的話，可以猜測出tomcat在這里是使用ConcurrentHashMap和WeakHashMap做了分代的緩存。在put方法里，在插入一個k-v時，先檢查eden緩存的容量是不是超了。沒有超就直接放入eden緩存，如果超了則鎖定longterm將eden中所有的k-v都放入longterm。再將eden清空并插入k-v。在get方法中，也是優(yōu)先從eden中找對應(yīng)的v，如果沒有則進入longterm緩存中查找，找到后就加入eden緩存并返回。

經(jīng)過這樣的設(shè)計，相對常用的對象都能在eden緩存中找到，不常用（有可能被銷毀的對象）的則進入longterm緩存。而longterm的key的實際對象沒有其他引用指向它時，gc就會自動回收heap中該弱引用指向的實際對象，弱引用進入引用隊列。longterm調(diào)用expungeStaleEntries()方法，遍歷引用隊列中的弱引用，并清除對應(yīng)的Entry，不會造成內(nèi)存空間的浪費。

4. WeakHashMap的數(shù)據(jù)結(jié)構(gòu)

前面已經(jīng)大概了解了WeakHashMap，接下來來分析WeakHashMap的源碼，先從它的數(shù)據(jù)結(jié)構(gòu)開始。

4.1 類的定義

public class WeakHashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V> {
}

java.lang.Object
   ?     java.util.AbstractMap<K, V>
         ?     java.util.WeakHashMap<K, V>

4.2 變量與常量

    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    private static final int MAXIMUM_CAPACITY = 1 << 30;
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;
    Entry<K,V>[] table;
    private int size;
    private int threshold;
    private final float loadFactor;
    private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
    int modCount;

DEFAULT_INITIAL_CAPACITY : 初始容量
MAXIMUM_CAPACITY : 最大容量
DEFAULT_LOAD_FACTOR : 默認加載因子
table : Entry數(shù)組
size : 實際存放的數(shù)據(jù)個數(shù)
threshold : 擴容閾值
loadFactor : 加載因子
queue : 引用隊列
modCount ：修改次數(shù)

4.3 Entry類

   private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
        V value;
        final int hash;
        Entry<K,V> next;
        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;
        }
        ...
    }

可以看到Entry類實現(xiàn)了Map.Entry接口，繼承弱引用(WeakReference)，屬性有key，value和next引用。

構(gòu)造器中需要傳入一個引用隊列，方法主要看getKey():

return (K) WeakHashMap.unmaskNull(get());

再來看看WeakHashMap的靜態(tài)方法unmaskNull():

    private static final Object NULL_KEY = new Object();
    static Object unmaskNull(Object key) {
        return (key == NULL_KEY) ? null : key;
    }

判斷key是否等于NULL_KEY來選擇是否返回null。

4.4 類關(guān)系圖

5. WeakHashMap的弱鍵回收

上面看完WeakHashMap的數(shù)據(jù)結(jié)構(gòu)，那么WeakHashMap是如何實現(xiàn)弱鍵回收的呢？其實根據(jù)前面的文章也能猜到，利用Reference和ReferenceQueue。

5.1 put數(shù)據(jù)

    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];
        tab[i] = new Entry<>(k, value, queue, h, e);
        if (++size >= threshold)
            resize(tab.length * 2);
        return null;
    }
   private static Object maskNull(Object key) {
        return (key == null) ? NULL_KEY : key;
    }

判斷key是否為null，為null的話將key賦值為NULL_KEY。
計算key的hash值，然后根據(jù)hash值查找待插入的位置。
遍歷Entry數(shù)組，看該鍵是否已存在，存在的話則替換舊值，并返回舊值。
不存在則構(gòu)建Entry對象存入數(shù)組。

這個流程和HashMap，HashTable等差不多。

5.2 get數(shù)據(jù)

    public V get(Object 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;
    }

一句話，先根據(jù)key的hash值找到索引位置，然后拿到Entry對象，再判斷該Entry是否存在下一個引用(即hash碰撞)，遍歷該單鏈表，比較value值。

5.3 弱鍵如何回收？

根據(jù)上面的分析就很容易得出了，WeakHashMap內(nèi)部的數(shù)據(jù)存儲是用Entry[]數(shù)組，即鍵值對數(shù)組。

Entry類繼承于WeakReferece(弱引用)，弱引用的特點再重申下：當JVM進行垃圾回收時，無論內(nèi)存是否充足，都會回收被弱引用關(guān)聯(lián)的對象。

在構(gòu)造一個Entry對象的時候，會傳入一個ReferenceQueue，key為弱引用包裹的對象：

    public WeakReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }

再來看看WeakHashMap如何清理已經(jīng)被回收的key的，被回收的key會存放在引用隊列中：

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;
                }
            }
        }
    }

遍歷引用隊列，然后刪除已被回收的鍵值對(從數(shù)組移除，改變單鏈表結(jié)點引用，將value賦值為null)，該方法會在WeakHashMap增刪改查、擴容的地方調(diào)用。

因為一個key-value存放到WeakHashMap中后，key會被用弱引用包起來存儲，如果這個key在WeakHashMap外部沒有強引用的話，GC時將被回收，然后WeakHashMap根據(jù)引用隊列對已回收的key做清理。

到此這篇關(guān)于Java中WeakHashMap的弱鍵回收機制的文章就介紹到這了,更多相關(guān)WeakHashMap弱鍵回收內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: