Java 中最大的資料結構:LinkedHashMap 瞭解一下?

莫那·魯道發表於2018-05-19

前言

Map 家族數量眾多,其中 HashMap 和 ConcurrentHashMap 用的最多,而 LinkedHashMap 似乎則是不怎麼用的,但是他卻有著順序。兩種,一種是新增順序,一種是訪問順序。

詳情

LinkedHashMap 繼承了 HashMap。那麼如果是你,你怎麼實現這兩個順序呢?

如果實現新增順序的話,我們可以在該類中,增加一個連結串列,每個節點對應 hash 表中的桶。這樣,迴圈遍歷的時候,就可以按照連結串列遍歷了。只是會增大記憶體消耗。

如果實現訪問順序的話,同樣也可以使用連結串列,但每次讀取資料時,都需要更新一下連結串列,將最近一次讀取的放到鏈尾。這樣也就能夠實現。此時也可以跟進這個特性實現 LRU(Least Recently Used) 快取。

如何使用?

下面是個小 demo

LinkedHashMap<Integer, Integer> map = new LinkedHashMap<>(16, 0.75f, true);
for (int i = 0; i < 10; i++) {
  map.put(i, i);
}

for (Map.Entry entry : map.entrySet()) {
  System.out.println(entry.getKey() + ":" + entry.getValue());
}
map.get(3);
System.out.println();
for (Map.Entry entry : map.entrySet()) {
  System.out.println(entry.getKey() + ":" + entry.getValue());
}
複製程式碼

列印結果:

0:0
1:1
2:2
3:3
4:4
5:5
6:6
7:7
8:8
9:9

0:0
1:1
2:2
4:4
5:5
6:6
7:7
8:8
9:9
3:3
複製程式碼

首先構造方法是有意思的,比 HashMap 多了一個 accessOrder boolean 引數。表示,按照訪問順序來排序。最新訪問的放在連結串列尾部。

如果是預設的,則是按照新增順序,即 accessOrder 預設是 false。

原始碼實現

如果看 LinkedHashMap 內部原始碼,會發現,內部確實維護了一個連結串列:

    /**
     * 雙向連結串列的頭,最久訪問的
     */
    transient LinkedHashMap.Entry<K,V> head;

    /**
     * 雙向連結串列的尾,最新訪問的
     */
    transient LinkedHashMap.Entry<K,V> tail;
複製程式碼

而這個 LinkedHashMap.Entry 內部也維護了雙向連結串列必須的元素,before,after:

    /**
     * HashMap.Node subclass for normal LinkedHashMap entries.
     */
    static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }
複製程式碼

在新增元素的時候,會追加到尾部。

    Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
        LinkedHashMap.Entry<K,V> p =
            new LinkedHashMap.Entry<K,V>(hash, key, value, e);
        linkNodeLast(p);
        return p;
    }

    // link at the end of list
    private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
        LinkedHashMap.Entry<K,V> last = tail;
        tail = p;
        if (last == null)
            head = p;
        else {
            p.before = last;
            last.after = p;
        }
    }
複製程式碼

在 get 的時候,會根據 accessOrder 屬性,修改連結串列順序:

    public V get(Object key) {
        Node<K,V> e;
        if ((e = getNode(hash(key), key)) == null)
            return null;
        if (accessOrder)
            afterNodeAccess(e);
        return e.value;
    }

    void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        if (accessOrder && (last = tail) != e) {
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.after = null;
            if (b == null)
                head = a;
            else
                b.after = a;
            if (a != null)
                a.before = b;
            else
                last = b;
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
    }
複製程式碼

同時注意:這裡修改了 modCount,即使是讀操作,併發也是不安全的。

如何實現 LRU 快取?

LRU 快取:LRU(Least Recently Used,最近最少使用)演算法根據資料的歷史訪問記錄來進行淘汰資料,其核心思想是“如果資料最近被訪問過,那麼將來被訪問的機率也更高”。

LinkedHashMap 並沒有幫我我們實現具體,需要我們自己實現 。具體實現方法是 removeEldestEntry 方法。

一起來看看原理。

首先,HashMap 在 putVal 方法最後,會呼叫 afterNodeInsertion 方法,其實就是留給 LinkedHashMap 的。而 LinkedHashMap 的具體實現則是根據一些條件,判斷是否需要刪除 head 節點。

原始碼如下:

    void afterNodeInsertion(boolean evict) { // possibly remove eldest
        LinkedHashMap.Entry<K,V> first;
        if (evict && (first = head) != null && removeEldestEntry(first)) {
            K key = first.key;
            removeNode(hash(key), key, null, false, true);
        }
    }
複製程式碼

evict 參數列示是否需要刪除某個元素,而這個 if 判斷需要滿足的條件如上:head 不能是 null,呼叫 removeEldestEntry 方法,返回 true 的話,就刪除這個 head。而這個方法預設是返回 false 的,等待著你來重寫。

所以,removeEldestEntry 方法的實現通常是這樣:

public boolean removeEldestEntry(Map.Entry<K, V> eldest){    
   return size() > capacity;  
} 
複製程式碼

如果長度大於容量了,那麼就需要清除不經常訪問的快取了。afterNodeInsertion 會呼叫 removeNode 方法,刪除掉 head 節點 —— 如果 accessOrder 是 true 的話,這個節點就是最不經常訪問的節點。

拾遺

LinkedHashMap 重寫了一些 HashMap 的方法,例如 containsValue 方法,這個方法大家猜一猜,怎麼重寫比較合理?

HashMap 使用了雙重迴圈,先迴圈外層的 hash 表,再迴圈內層的 entry 連結串列。效能可想而知。

但 LinkedHashMap 內部有個元素連結串列,直接遍歷連結串列就行。相對而言而高很多。

    public boolean containsValue(Object value) {
        for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {
            V v = e.value;
            if (v == value || (value != null && value.equals(v)))
                return true;
        }
        return false;
    }
複製程式碼

這也算一種空間換時間的策略吧。

get 方法當然也是要重寫的。因為需要根據 accessOrder 更新連結串列。

總結

雪薇的總結的一下:

LinkedHashMap 內部包含一個雙向連結串列維護順序,支援兩種順序——新增順序,訪問順序。

預設就是按照新增順序來的,如果要改成訪問順序的話,構造方法中的 accessOrder 需要設定成 true。這樣,每次呼叫 get 方法,就會將剛剛訪問的元素更新到連結串列尾部。

關於 LRU,在accessOrder 為 true 的模式下,你可以重寫 removeEldestEntry 方法,返回 size() > capacity,這樣,就可以刪除最不常訪問的元素。

相關文章