LinkedHashMap源码和实现LRU算法

今天药忘吃喽~ 2024-04-19 16:32 84阅读 0赞

LinkedHashMap特别有意思，它不仅仅是在HashMap上增加Entry的双向链接，它更能借助此特性实现保证Iterator迭代按照插入顺序(以insert模式创建LinkedHashMap)或者实现LRU(Least Recently Used最近最少算法，以access模式创建LinkedHashMap)。

下面是LinkedHashMap的get方法的代码

public V get(Object key) {
            Entry<K,V> e = (Entry<K,V>)getEntry(key);
            if (e == null)
                return null;
            e.recordAccess(this);
            return e.value;
        }

其中有一段：e.recordAccess(this)。下面我们进入Entry的定义

void recordAccess(HashMap<K,V> m) {
                LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
                if (lm.accessOrder) {
                    lm.modCount++;
                    remove();
                    addBefore(lm.header);
                }
            }

这里的addBefore(lm.header)是做什么呢?再看

private void addBefore(Entry<K,V> existingEntry) {
                after  = existingEntry;
                before = existingEntry.before;
                before.after = this;
                after.before = this;
            }

从这里可以看到了，addBefore(lm.header)是把当前访问的元素挪到head的前面,即最近访问的元素被放到了链表头，如此要实现LRU算法只需要从链表末尾往前删除就可以了，多么巧妙的方法。

在看到LinkedHashMap之前，我以为实现LRU算法是在每个元素内部维护一个计数器，访问一次自增一次，计数器最小的会被移除。但是要想到，每次add的时候都需要做这么一次遍历循环，并取出最小的抛弃，在HashMap较大的时候效率很差。当然也有其他方法来改进，比如建立<访问次数,LinkedHashMap元素的key>这样的TreeMap，在add的时候往TreeMap里也插入一份，删除的时候取最小的即可，改进了效率但没有LinkedHashMap内部的默认实现来的简捷。

LinkedHashMap是什么时候删除的呢？

void addEntry(int hash, K key, V value, int bucketIndex) {
            super.addEntry(hash, key, value, bucketIndex);
            // Remove eldest entry if instructed
            Entry<K,V> eldest = header.after;
            if (removeEldestEntry(eldest)) {
                removeEntryForKey(eldest.key);
            }
        }

在增加Entry的时候，通过removeEldestEntry(eldest)判断是否需要删除最老的Entry，如果需要则remove。注意看这里Entry<K,V> eldest=header.after，记得我们前面提过LinkedHashMap还维护一个双向链表，这里的header.after就是链表尾部最后一个元素(头部元素是head.before)。  
LinkedHashMap默认的removeEldestEntry方法如下

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
            return false;
        }

总是返回false，所以开发者需要实现LRU算法只需要继承LinkedHashMap并重写removeEldestEntry方法，下面以MyBatis的LRU算法的实现举例  
keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) \{  
private static final long serialVersionUID = 4267176411845948333L;

protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
        boolean tooBig = size() > size;
        if (tooBig) {
          eldestKey = eldest.getKey();
        }
        return tooBig;
      }
    };

开发者的子类并不需要直接操作eldest(上例中获得eldestKey只是MyBatis需要映射到Cache对象中的元素)，只要根据自己的条件(一般是元素个数是否到达阈值)返回true/false即可。注意，要按照LRU排序必须在new LinkedHashMap()的构造函数的最后一个参数传入true(true代表LinkedHashMap内部的双向链表按访问顺序排序，false代表按插入顺序排序)。

在LinkedHashMap的注释里明确提到，该类在保持插入顺序、不想HashMap那样混乱的情况下，又没有像TreeMap那样的性能损耗。同时又能够很巧妙地实现LRU算法。其他方面和HashMap功能一致。有兴趣的同学可以仔细看看LinkedHashMap的实现。

LinkedHashMap实现LRU;具体实现如下：只需要重写removeEldestEntry方法即可

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.LinkedHashMap;
    import java.util.Map;
    import java.util.Map.Entry;
     
    public class LRULinkedMap<K, V> {
     
    	/**
         * 最大缓存大小
         */
    	private int cacheSize;
    	
    	private LinkedHashMap<K, V> cacheMap;
    	
    	public LRULinkedMap(int cacheSize){
    		this.cacheSize = cacheSize;
    		
    		cacheMap = new LinkedHashMap(cacheSize, 0.75F, true){
     
    			@Override
    			protected boolean removeEldestEntry(Entry eldest) {
    					return cacheSize + 1 >= cacheMap.size();
    			}
    		};
    	}
    	
    	public void put(K key, V value){
    		cacheMap.put(key, value);
    	}
    	
    	public V get(K key){
    		return cacheMap.get(key);
    	}
    	
    	public Collection<Map.Entry<K, V>> getAll(){
    		return new ArrayList<Map.Entry<K, V>>(cacheMap.entrySet());
    	}
    	
    	public static void main(String[] args) {
    		LRULinkedMap<String, Integer> map = new LRULinkedMap<>(3);
    		map.put("key1", 1);
    		map.put("key2", 2);
    		map.put("key3", 3);
    		
    		for (Map.Entry<String, Integer> e : map.getAll()){
    			System.out.println(e.getKey()+"====>"+e.getValue());
    		}
    		System.out.println("\n");
    		map.put("key4", 4);
    		for (Map.Entry<String, Integer> e : map.getAll()){
    			System.out.println(e.getKey()+"====>"+e.getValue());
    		}
    		
    	}
    	 
    }

原文转自  
https://www.cnblogs.com/mengheng/p/3683137.html

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pqY2phdmE_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pqY2phdmE_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/1380e627b014420996ba6d4f0b6c08cf.png