什么是LRU算法？

LRU

一、什么是LRU？LRU就是Least Recently Used的缩写，翻译过来是：最近最少使用，什么意思呢，请看下面这个示例。

我们要在有限的内存中存放一些键值对，这些键值对很多，所有的键值对所占内存大于物理可用内存，并且每个键值对被访问的情况也是不一样的。当内存用尽的时候，这时新来了一个键值对，这时我们要如何处理呢？从内存中删除“潜水”时间最长的那个键值对，这样就可以把新来的键值对存入内存了，这就是LRU算法，也是在Redis缓存丢弃策略的一种。上面说的“潜水”时间最长指的是：被人遗忘时间最长的那个键值对，遗忘指的是没有被人访问过。
总结一下，LRU就是当你内存中数据到达指定容量的时候，LRU选择将最长时间没有被使用过的那个键值对从内存中移除。

二、 明白什么是LRU算法之后，我们来看看该怎么实现它？
1 我们需要存储键值对
2 可以指定可以存储多少个键值对
3 当存储容量满了以后，移除最长时间没有被访问过的键值对
分析一下上面的需求

• 存储键值对：第一想法是使用HashMap存储，毕竟HashMap是为“存储键值对而生”。
• 指定容量：这也容易，每次向map中put键值对后，就检查map的容量是否超出了指定的容量，如果超出了，从map中移除一个元素即可。
• 移除谁？难点在这里，当map在put操作之后超出了指定容量，我们移除谁？怎么找出那个“潜水”时间最长的键值对呢？第一个想法是我们需要维护一个有序的链表，这个链表从前到后“潜水”时间越来越短。这样当map的容量满了以后我们只需要获取链表头部元素，然后从map中移除该键值对即可，这也说明了链表节点中需要包含对应键值对的key，否则找到链表头结点后如何移除呢？
• 为什么使用链表？容量指定的情况下，为什么不使用数组呢？原因如下，“潜水”时间最长的键值对经常发送变化，也就是链表中元素顺序经常发生改变，另外一方面，链表的插入和操作删除效率要比数组高。
• 如何维护链表节点的顺序？可以这样，当一个“潜水”的键值对被访问后，把该节点从链表中移除，然后把这个节点插入到链表末尾，这样就可以保证链表第一个元素永远是“潜水”时间最长的键值对；链表末尾的元素永远是最近被访问过的元素。这样当map超出指定容量之后只需要删除链表头的键值对即可。

public class LRUCache {
	static class Node {
		//键值对
		private int key;
		private int value;
		//维护“潜水”键值对，双向链表
		private Node pre;
		private Node next;
		//构造器
		public Node(){}
		public Node(int key,int value){
			this.key = key;
			this.value = value;
		}
	}
	
	private int cap;//指定的容量
	//保留“潜水”双向链表的头尾指针
	private Node head;
	private Node tail;
	private HashMap<Integer,Node> map;//保存键值对的map 
	
	public LRUCache(int capacity){
		this.cap = capacity;
		head = new Node();//初始化头尾节点，这里的头结点是辅助节点,head节点不存储任何有效元素
		tail = head;
		map = new HashMap<>((int)(cap/0.75)+1);//构造器初始容量这样设置可以保证map不会发生扩容
	}
	
	//将指定节点从链表中删除
	private void removeNode(Node cur){
		if(cur == tail){
			tail = tail.pre;
			tail.next = null;
			cur.pre = null;
		}else{
			cur.pre.next = cur.next;
			cur.next.pre = cur.pre;
			cur.pre = null;
			cur.next = null;
		}
	}
	
	//将指定节点追加到链表末尾
	private void add(Node cur){
		tail.next = cur;
		cur.pre = tail;
		
		tail = cur;
	}
	
	//访问一个键值对
	public int get(int key){
		Node cur = map.get(key);
		if(cur == null){//不存在这个key
			return -1;
		}else{ //存在，含义是当前潜水节点已经被访问了,将这个节点添加到链表末尾
			removeNode(cur);
			add(cur);
			
			return cur.value;
		}
	}
	
	//存储一个键值对
	public void put(int key,int value){
		Node cur = map.get(key);
		if(cur == null){//put前不存在这个key
			cur = new Node(key,value);
			
			//将该键值对移动到链表末尾
			map.put(key, cur);
			add(cur);
			
			//超出了容量，移除链表头结点后面那个元素(头结点是辅助节点)
			if(map.size()>cap && head!=tail){
				Node outDate = head.next;
				removeNode(outDate);
				map.remove(outDate.key);
			}
		}else{ //put之前已经存在,将这个键值对移到链表末尾即可
			removeNode(cur);
			add(cur);
			cur.value = value; //更新这个key的值
		}
	}
	
}

说明：

LinkedHashMap其实是可以直接支持LRU的，面试的时候可以提及这一点，但是面试官不会支持你使用LinkedHashMap实现LRU。实质LinkedHashMap底层实现也是类似原理，使用LinkedHashMap实现LRU代码如下：

//继承一下LinkedHashMap这个类，
//使用LinkedHashMap实现LRU算法
class LRULinkedHashMap<K,V> extends LinkedHashMap<K,V>{
      //定义缓存的容量
      private int capacity;
      //带参数的构造器   
      LRULinkedHashMap(int capacity){
          //调用LinkedHashMap的构造器
          super(capacity,0.75f,true);
          //传入指定的缓存最大容量
          this.capacity=capacity;
      }
     //返回true就会移除“潜水”时间最长的键值对
      @Override
      public boolean removeEldestEntry
         (Map.Entry<K, V> eldest){
         //参数eldest就是“潜水”时间最长的键值对，可以获得对应的
         //key,value
          return size()>capacity;
      }  
  }

原文

• https://blog.csdn.net/liewen_/article/details/83150476