数据结构和算法 之 LinkedHashMap实现LRU算法

​   目录

              1、背景介绍

              2、LinkHashMap实现

              3、LinkHashMap实现原理

---

一、背景介绍

LRU全称是Least Recently Used，即最近最久未使用的意思。LRU算法的主要思想：设置一个缓存大小阈值，超过阈值就去删除最老的数据。新添加数据或者访问数据的时候保证最老的数据总是在链表的头部，最新的数据总是在尾部，这样每次需要删除数据时把头部数据删除即可。

二、LinkHashMap实现

在Java当中，LinkHashMap已经实现了LRU的大部分功能，具体删除时机需要我们自己实现指定，废话不多说，直接看实例。

/**
 * @author: wenyixicodedog
 * @create: 2020-07-25
 * @description:
 */
public class LinkHashMapLRU extends LinkedHashMap<String, String> {
​
    public LinkHashMapLRU(int initialCapacity, float loadFactor, boolean accessOrder) {
        super(initialCapacity, loadFactor, accessOrder);
    }
​
    public LinkHashMapLRU() {
​
    }
​
    @Override
    protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
        //当map的容量大于等于5的时候,再插入新元素就移除旧的元素
        return this.size() >= 5;
    }
​
    public static void main(String[] args) {
        LinkHashMapLRU map = new LinkHashMapLRU(5, 0.75F, true);
        map.put("1", "one");
        map.put("2", "two");
        map.put("3", "three");
        map.put("4", "four");
        System.out.println("================原始数据===================");
        print(map);
        map.get("3");
        System.out.println("================访问一次3===================");
        print(map);
​
        map.get("1");
        map.get("2");
        System.out.println("===============访问一次1、2=====================");
        print(map);
        System.out.println("===============新添加元素5=====================");
        map.put("5", "five");
        print(map);
    }
​
    static void print(LinkedHashMap<String, String> map) {
        map.keySet().iterator().forEachRemaining(System.out::println);
    }
​
}

执行结果如下：

================原始数据===================
1
2
3
4
================访问一次3===================
1
2
4
3
===============访问一次1、2=====================
4
3
1
2
===============新添加元素5=====================
3
1
2
5

从实例中我们不难看出，初始状态1,2,3,4之后我们访问3之后，3就作为最新被访问的数据放到了最后，其他数据依次在前面，然后访问1,2，1,2被放在了最后，4,3依次在前，最后新添加5，被放在最后，最前面的4被删除。

三、LinkHashMap实现原理

在这个示例中主要进行了两个操作，添加和访问数据，我们首先看LinkHashMap添加数据的源码。

 public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
​
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // 如果当前添加的元素已经存在在map中
            if (e != null) { 
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                //访问数据之后将该数据放置在链表尾部
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        // 如果当前添加的元素不存在在map中    
        // 添加元素之后判断是否需要删除头部元素，若需要，则删除。
        afterNodeInsertion(evict);
        return null;
    }
​
    void afterNodeInsertion(boolean evict) { // possibly remove eldest
        LinkedHashMap.Entry<K,V> first;
        // 删除旧元素执行时机需要我们自己手动指定——removeEldestEntry
        if (evict && (first = head) != null && removeEldestEntry(first)) {
            K key = first.key;
            removeNode(hash(key), key, null, false, true);
        }
    }

然后接下来看访问数据的时候源码执行逻辑。

 public V get(Object key) {
        Node<K,V> e;
        if ((e = getNode(hash(key), key)) == null)
            return null;
        if (accessOrder)
            // 将新访问的数据放置到链表尾部 
            afterNodeAccess(e);
        // 返回数据value值    
        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;
        }
    }

LinkHashMap源码当中其实是通过三个核心方法进行实现的，这三个核心方法是实现的HashMap的方法。

//把新访问元素放到链表尾部
 void afterNodeAccess(Node<K,V> p) { }
 //在插入新元素后，检查是否要删除最头部元素，需要则删除
 void afterNodeInsertion(boolean evict) { }
 //在删除元素之后调整头尾部元素
 void afterNodeRemoval(Node<K,V> p) { }

不仅仅在Java当中，在Redis、mybatis中，LRU实现原理与其类似。

以下是mybatis的实现：

public class LruCache implements Cache {
​
  private final Cache delegate;
  private Map<Object, Object> keyMap;
  private Object eldestKey;
​
  public LruCache(Cache delegate) {
    this.delegate = delegate;
    setSize(1024);
  }
​
  // 省略部分代码
​
  public void setSize(final int size) {
    keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
      private static final long serialVersionUID = 4267176411845948333L;
​
      @Override
      protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
        boolean tooBig = size() > size;
        if (tooBig) {
          eldestKey = eldest.getKey();
        }
        return tooBig;
      }
    };
  }
​
  // 省略部分代码

更多内容持续更新中，感兴趣的朋友请移步至个人公众号，谢谢支持😜😜......

公众号：wenyixicodedog