LinkedHashMap源码分析与LRU实现

LinkedHashMap可认为是哈希表和链接列表综合实现，并允许使用null值和null键。LinkedHashMap实现与HashMap的不同之处在于，LinkedHashMap维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。 LinkedHashMap的实现不是同步的。如果多个线程同时访问LinkedHashMap，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。

1.LinkedHashMap的存储结构  

LinkedHashMap中加入了一个head头结点，将所有插入到该LinkedHashMap中的Entry按照插入的先后顺序（accessOrder标志位默认为false）依次加入到以head为头结点的双向循环链表的尾部。

LinkedHashMap实际上就是HashMap和LinkedList两个集合类的存储结构的结合。在LinkedHashMapMap中，所有put进来的Entry都保存在如图所示的哈希表中，但它又额外定义了一个以head为头结点的空的双向循环链表，每次put进来Entry，除了将其保存到对哈希表中对应的位置上外，还要将其插入到双向循环链表的尾部。

下面我们来分析LinkedHashMap的源代码。

2.LinkedHashMap成员变量

LinkedHashMap采用的hash算法和HashMap相同，但它重新定义了数组中保存的元素Entry，该Entry除了保存当前对象的引用外，还保存了其上一个元素before和下一个元素after的引用，从而在哈希表的基础上又构成了双向链接列表。

[java] view plain copy

 

1. 1.//双向循环链表的头结点，整个LinkedHashMap中只有一个header，    
2. 2.//（此链表不同于HashMap里面的那个next链表）    
3. 3.//它将哈希表中所有的Entry贯穿起来，header中不保存key-value对，只保存前后节点的引用    
4. 4.   private transient Entry<K,V> header;    
5. 5.    
6. 6.//双向链表中元素排序规则的标志位。    
7. 7.//accessOrder为false，表示按插入顺序排序    
8. 8.//accessOrder为true，表示按访问顺序排序    
9. 9.    private final boolean accessOrder;    
10. 10.    
11. 11.    
12. 12. /**   
13. 13. * LinkedHashMap的Entry元素。   
14. 14. * 继承HashMap的Entry元素，又保存了其上一个元素before和下一个元素after的引用。   
15. 15. */      
16. 16.private static class Entry<K,V> extends HashMap.Entry<K,V> {      
17. 17.    Entry<K,V> before, after;      
18. 18.    ……  //Entry类涉及到的方法，下面会继续分析    
19. 19.}    

3.构造函数

LinkedList一共提供了五个构造方法。

[java] view plain copy

 

1. 1.// 构造方法1，构造一个指定初始容量和加载因子的、按照插入顺序的LinkedList    
2. 2.//加载因子取默认的0.75f      
3. 3.    
4. 4.public LinkedHashMap(int initialCapacity, float loadFactor) {    
5. 5.    super(initialCapacity, loadFactor);    
6. 6.    accessOrder = false;    
7. 7.}    
8. 8.    
9. 9.// 构造方法2，构造一个指定初始容量的LinkedHashMap，取得键值对的顺序是插入顺序    
10. 10.//加载因子取默认的0.75f      
11. 11.    
12. 12.public LinkedHashMap(int initialCapacity) {    
13. 13.    super(initialCapacity);    
14. 14.    accessOrder = false;    
15. 15.}    
16. 16.    
17. 17.// 构造方法3，用默认的初始化容量和加载因子创建一个LinkedHashMap，取得键值对的顺序是插入顺序    
18. 18.//加载因子取默认的0.75f      
19. 19.    
20. 20.public LinkedHashMap() {    
21. 21.    super();    
22. 22.    accessOrder = false;    
23. 23.}    
24. 24.    
25. 25.// 构造方法4，通过传入的map创建一个LinkedHashMap，容量为默认容量（16）和    
26. 26.//(map.zise()/DEFAULT_LOAD_FACTORY)+1的较大者，加载因子为默认值0.75    
27. 27.    
28. 28.public LinkedHashMap(Map<? extends K, ? extends V> m) {    
29. 29.    super(m);    
30. 30.    accessOrder = false;    
31. 31.}    
32. 32.    
33. 33.// 构造方法5，根据指定容量、加载因子和指定链表中的元素排序的规则  创建一个LinkedHashMap    
34. 34.public LinkedHashMap(int initialCapacity,    
35. 35.             float loadFactor,    
36. 36.                         boolean accessOrder) {    
37. 37.    super(initialCapacity, loadFactor);    
38. 38.    this.accessOrder = accessOrder;    
39. 39.}    

我们已经知道LinkedHashMap的Entry元素继承HashMap的Entry，提供了双向链表的功能。在HashMap的构造器中，最后会调用init()方法，进行相关的初始化，这个方法在HashMap的实现中是空方法(感叹模板模式的精妙！)，只是提供给子类实现相关的初始化调用。LinkedHashMap重写了init()方法，在调用父类的构造方法完成构造后，进一步实现了对其元素Entry的初始化操作。分析init()方法，的确是对header进行了初始化，并构造成一个双向循环链表（和LinkedList的存储结构是一样的）。

[java] view plain copy

 

1. 1.void init() {    
2. 2.    header = new Entry<K,V>(-1, null, null, null);    
3. 3.    header.before = header.after = header;    
4. 4.}    

4.元素存储

LinkedHashMap重写了父类HashMap的put方法调用的子方法void addEntry(int hash, K key, V value, int bucketIndex) 和void createEntry(int hash, K key, V value, int bucketIndex)，提供了自己特有的双向链接列表的实现。 

[java] view plain copy

 

1. 1.//覆写HashMap中的addEntry方法，LinkedHashmap并没有覆写HashMap中的put方法，    
2. 2.    //而是覆写了put方法所调用的addEntry方法和recordAccess方法，    
3. 3.    //put方法在插入的key已存在的情况下，会调用recordAccess方法，    
4. 4.    //在插入的key不存在的情况下，要调用addEntry插入新的Entry    
5. 5.void addEntry(int hash, K key, V value, int bucketIndex) {    
6. 6.    //创建新的Entry，并插入到LinkedHashMap中    
7. 7.    createEntry(hash, key, value, bucketIndex);    
8. 8.    
9. 9.    //双向链表的第一个有效节点（header后的那个节点）为近期最少使用的节点    
10. 10.    Entry<K,V> eldest = header.after;    
11. 11.    //如果有必要，则删除掉该近期最少使用的节点，    
12. 12.    //这要看对removeEldestEntry的覆写,由于默认为false，因此默认是不做任何处理的。    
13. 13.    if (removeEldestEntry(eldest)) {    
14. 14.        removeEntryForKey(eldest.key);    
15. 15.    } else {    
16. 16.        //超过阈值，扩容到原来的2倍    
17. 17.        if (size >= threshold)    
18. 18.            resize(2 * table.length);    
19. 19.    }    
20. 20.}    
21. 21.    
22. 22.void createEntry(int hash, K key, V value, int bucketIndex) {    
23. 23.    HashMap.Entry<K,V> old = table[bucketIndex];    
24. 24.    Entry<K,V> e = new Entry<K,V>(hash, key, value, old);    
25. 25.    table[bucketIndex] = e;    
26. 26.    // 调用元素的addBrefore方法，将元素加入到哈希、双向链接列表。    
27. 27.    //每次插入Entry时，都将其移到双向链表的尾部，    
28. 28.    //这便会按照Entry插入LinkedHashMap的先后顺序来迭代元素，    
29. 29.    //同时，新put进来的Entry是最近访问的Entry，把其放在链表末尾，符合LRU算法的实现    
30. 30.    e.addBefore(header);    
31. 31.    size++;    
32. 32.}    
33. 33.//双向循环立链表中，将当前的Entry插入到existingEntry的前面    
34. 34.private void addBefore(Entry<K,V> existingEntry) {    
35. 35.    after  = existingEntry;    
36. 36.    before = existingEntry.before;    
37. 37.    before.after = this;    
38. 38.    after.before = this;    
39. 39.}    
40. 40.    
41. 41.//该方法默认返回false，我们一般在用LinkedHashMap实现LRU算法时，    
42. 42.//要覆写该方法，一般的实现是，当设定的内存（这里指节点个数）达到最大值时，返回true，    
43. 43.//这样put新的Entry（该Entry的key在哈希表中没有已经存在）时，    
44. 44.//就会调用removeEntryForKey方法，将最近最少使用的节点删除（head后面的那个节点，实际上是最近没有使用）。    
45. 45.    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {    
46. 46.        return false;    
47. 47.    }    
48. 48.}    

5.元素读取

LinkedHashMap重写了父类HashMap的get方法。由于的链表的增加、删除操作是常量级的，性能不会带来较大损失。LinkedHashMap 最牛逼的地方在于recordAccess()方法。

[java] view plain copy

 

1. 1.//覆写HashMap中的get方法，通过getEntry方法获取Entry对象。    
2. 2.    //注意这里的recordAccess方法，    
3. 3.    //如果链表中元素的排序规则是按照插入的先后顺序排序的话，该方法什么也不做，    
4. 4.    //如果链表中元素的排序规则是按照访问的先后顺序排序的话，则将e移到链表的末尾处。    
5. 5.public V get(Object key) {    
6. 6.    // 调用父类HashMap的getEntry()方法，取得要查找的元素。    
7. 7.    Entry<K,V> e = (Entry<K,V>)getEntry(key);    
8. 8.    if (e == null)    
9. 9.        return null;    
10. 10.    // 记录访问顺序。    
11. 11.    e.recordAccess(this);    
12. 12.    return e.value;    
13. 13.}    
14. 14.//覆写HashMap中的recordAccess方法（HashMap中该方法为空），    
15. 15.//当调用父类的put方法，在发现插入的key已经存在时，会调用该方法，    
16. 16.//调用LinkedHashmap覆写的get方法时，也会调用到该方法，    
17. 17.//该方法提供了LRU算法的实现，它将最近使用的Entry放到双向循环链表的尾部，    
18. 18.//accessOrder为true时，get方法会调用recordAccess方法    
19. 19.//put方法在覆盖key-value对时也会调用recordAccess方法    
20. 20.//它们导致Entry最近使用，因此将其移到双向链表的末尾    
21. 21.void recordAccess(HashMap<K,V> m) {    
22. 22.    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;    
23. 23.    //如果链表中元素按照访问顺序排序，则将当前访问的Entry移到双向循环链表的尾部，    
24. 24.    //如果是按照插入的先后顺序排序，则不做任何事情。    
25. 25.    if (lm.accessOrder) {    
26. 26.        lm.modCount++;    
27. 27.        remove();//移除当前访问的Entry    
28. 28.        addBefore(lm.header);//将当前访问的Entry插入到链表的尾部    
29. 29.    }    
30. 30.}    

6.元素删除

LinkedHashMap没有重写remove(Object key)方法，重写了被remove调用的recordRemoval方法，再一次感叹模板方法模式的精妙！
HahsMap remove(Object key)把数据从横向数组 * 竖向next链表里面移除之后（就已经完成工作了，所以HashMap里面recordRemoval是空的实现调用了此方法
但在LinkedHashMap里面，还需要移除header链表里面Entry的after和before关系。

7.元素遍历

[java] view plain copy

 

1. 1.//迭代器    
2. 2.    private abstract class LinkedHashIterator<T> implements Iterator<T> {    
3. 3.        Entry<K,V> nextEntry    = header.after;    
4. 4.        Entry<K,V> lastReturned = null;    
5. 5.    
6. 6.        /**  
7. 7.         * The modCount value that the iterator believes that the backing  
8. 8.         * List should have.  If this expectation is violated, the iterator  
9. 9.         * has detected concurrent modification.  
10. 10.         */    
11. 11.        int expectedModCount = modCount;    
12. 12.    
13. 13.        public boolean hasNext() {    
14. 14.            return nextEntry != header;    
15. 15.        }    
16. 16.    
17. 17.        public void remove() {    
18. 18.            if (lastReturned == null)    
19. 19.                throw new IllegalStateException();    
20. 20.            if (modCount != expectedModCount)    
21. 21.                throw new ConcurrentModificationException();    
22. 22.    
23. 23.            LinkedHashMap.this.remove(lastReturned.key);    
24. 24.            lastReturned = null;    
25. 25.            expectedModCount = modCount;    
26. 26.        }    
27. 27.        //从head的下一个节点开始迭代    
28. 28.        Entry<K,V> nextEntry() {    
29. 29.            if (modCount != expectedModCount)    
30. 30.                throw new ConcurrentModificationException();    
31. 31.            if (nextEntry == header)    
32. 32.                throw new NoSuchElementException();    
33. 33.    
34. 34.            Entry<K,V> e = lastReturned = nextEntry;    
35. 35.            nextEntry = e.after;    
36. 36.            return e;    
37. 37.        }    
38. 38.    }    
39. 39.    //key迭代器    
40. 40.    //看出这三个类都很简单，只有一个next()方法，next()方法也只是去调用LinkedHashIterator类中相应的方法    
41. 41.    private class KeyIterator extends LinkedHashIterator<K> {    
42. 42.        public K next() { return nextEntry().getKey(); }    
43. 43.    }    
44. 44.    //value迭代器    
45. 45.    private class ValueIterator extends LinkedHashIterator<V> {    
46. 46.        public V next() { return nextEntry().value; }    
47. 47.    }    
48. 48.    //Entry迭代器    
49. 49.    private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {    
50. 50.        public Map.Entry<K,V> next() { return nextEntry(); }    
51. 51.    }    

8.基于LinkedHashMap实现LRU Cache

用LinkedHashmap实现LRU算法，就要覆写方法removeEldestEntry。该方法默认返回false，我们一般在用LinkedHashMap实现LRU算法时，要覆写该方法，一般的实现是，当设定的内存（这里指节点个数）达到最大值时，返回true，这样put新的Entry（该Entry的key在哈希表中没有已经存在）时，就会调用removeEntryForKey方法，将最近最少使用的节点删除（head后面的那个节点，实际上是最近没有使用）。

LinkedHashMap是如何实现LRU的。首先，当accessOrder为true时，才会开启按访问顺序排序的模式，才能用来实现LRU算法。我们可以看到，无论是put方法还是get方法，都会导致目标Entry成为最近访问的Entry，因此便把该Entry加入到了双向链表的末尾（get方法通过调用recordAccess方法来实现，put方法在覆盖已有key的情况下，也是通过调用recordAccess方法来实现，在插入新的Entry时，则是通过createEntry中的addBefore方法来实现），这样便把最近使用了的Entry放入到了双向链表的后面，多次操作后， 双向链表前面的Entry便是最近没有使用的，这样当节点个数满的时候，删除的最前面的Entry(head后面的那个Entry)便是最近最少使用的Entry。

[java] view plain copy

 

1. 1./*LRU是Least Recently Used 近期最少使用算法。  
2. 2. *通过HashLiekedMap实现LRU的算法的关键是，如果map里面的元素个数大于了缓存最大容量，则删除链表头元素  
3. 3. */    
4. 4.    
5. 5./*public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder)  
6. 6. *LRU参数参数：  
7. 7. *initialCapacity - 初始容量。  
8. 8. *loadFactor - 加载因子（需要是按该因子扩充容量）。  
9. 9. *accessOrder - 排序模式( true) - 对于访问顺序（get一个元素后，这个元素被加到最后，使用了LRU  最近最少被使用的调度算法），对于插入顺序，则为 false,可以不断加入元素。  
10. 10. */    
11. 11.    
12. 12. /*相关思路介绍：  
13. 13.  * 当有一个新的元素加入到链表里面时，程序会调用LinkedHahMap类中Entry的addEntry方法，  
14. 14.  *而该方法又会 会调用removeEldestEntry方法，这里就是实现LRU元素过期机制的地方，  
15. 15.  * 默认的情况下removeEldestEntry方法只返回false，表示可以一直表链表里面增加元素，在这个里  *修改一下就好了。   
16. 16.  *  
17. 17.  */    
18. 18.     
19. 19./*  
20. 20.测试数据：  
21. 21.11  
22. 22.7 0 7 1 0 1 2 1 2 6  
23. 23.*/    
24. 24.    
25. 25.import java.util.*;    
26. 26.public class LRULinkedHashMap<K,V> extends LinkedHashMap<K,V>{         
27. 27.    private int capacity;                     //初始内存容量    
28. 28.        
29. 29.    LRULinkedHashMap(int capacity){          //构造方法，传入一个参数    
30. 30.        super(16,0.75f,true);               //调用LinkedHashMap，传入参数        
31. 31.        this.capacity=capacity;             //传递指定的最大内存容量    
32. 32.    }    
33. 33.    @Override    
34. 34.    public boolean removeEldestEntry(Map.Entry<K, V> eldest){         
35. 35.        //，每加入一个元素，就判断是size是否超过了已定的容量    
36. 36.        System.out.println("此时的size大小="+size());    
37. 37.        if((size()>capacity))    
38. 38.        {    
39. 39.            System.out.println("超出已定的内存容量，把链表顶端元素移除："+eldest.getValue());    
40. 40.        }    
41. 41.        return size()>capacity;            
42. 42.    }    
43. 43.        
44. 44.    public static void main(String[] args) throws Exception{//方便实例，直接将异常抛出    
45. 45.        Scanner cin = new Scanner(System.in);    
46. 46.            
47. 47.        System.out.println("请输入总共内存页面数： ");    
48. 48.        int n = cin.nextInt();    
49. 49.        Map<Integer,Integer> map=new LRULinkedHashMap<Integer, Integer>(n);    
50. 50.            
51. 51.        System.out.println("请输入按顺序输入要访问内存的总共页面数： ");    
52. 52.        int y = cin.nextInt();    
53. 53.            
54. 54.        System.out.println("请输入按顺序输入访问内存的页面序列： ");    
55. 55.        for(int i=1;i<=y;i++)    
56. 56.        {    
57. 57.            int x = cin.nextInt();    
58. 58.            map.put(x,  x);      
59. 59.        }    
60. 60.        System.out.println("此时内存中包含的页面数是有:");    
61. 61.        //遍历此时内存中的页面并输出    
62. 62.        for(java.util.Map.Entry<Integer, Integer> entry: map.entrySet()){    
63. 63.            System.out.println(entry.getValue());    
64. 64.        }    
65. 65.    }    
66. 66.}  

9.总结

1.LinkedHashMap继承自HashMap，具有HashMap的大部分特性，比如支持null键和值，默认容量为16，装载因子为0.75，非线程安全等等；

2.LinkedHashMap通过设置accessOrder控制遍历顺序是按照插入顺序还是按照访问顺序。当accessOrder为true时，可以利用其完成LRU缓存的功能；

3.LinkedHashMap内部维护了一个双向循环链表，并且其迭代操作时通过链表完成的，而不是去遍历hash表。