LRU算法的原理与实现

Posted 2023-05-11

参考技术A LRU是Least Recently Used的缩写，即最近最少使用算法，应用面非常的广泛，比如redis当中的内存淘汰策略。因为计算机的内存都是有限的，当用户访问的数据如果存在内存当中直接返回的给用户的话，效率会非常快，但是如果内存不存在，在去磁盘里面查找的，效率会大打折扣。所以我们希望在有限的内存空间当中，多存放点热点数据，用户不经常访问的数据，尽量淘汰掉，避免占用内存空间。

使用双向链表来实现LRU 这篇文章已经用双向链表来实现过LRU算法了，但是基于双向链表的特性，使得该算法的时间复杂度为O(n)，显然不是最优的算法，那么有没有算法，可以达到O(1)，当然是有的，早早的计算机科学家已经想到，并且已经实现了。

在笔者介绍接下来的内容时，还是希望先了解一下两篇博文：
一、 图解HashMap原理
二、 图解LinkedHashMap

之前使用双向链表去实现LRU算法时，时间复杂度没有达到O(1)，主要原因在于遍历结点时，带来的时间开销，那么换句话说，要实现遍历结点时，时间复杂度为O(1)，第一时间想到的应该是hash数组，但是hash算法可能会存在不同的key值，产生相同的hash值，那么可以将不同key，但是相同hash值的结点，以单链表的形式存放。这样仅仅是实现了存取时间复杂度为O(1)，如何实现数据能够按访问顺序存放呢？并且增删的时间复杂度为O(1)，这个可以使用双向链表来实现，所以综合来讲，就是实现散列数组+双向链表来使用LRU，可以达到时间复杂度为O(1)。

逻辑视图如下:

咋一看这个图乱的很，稍微解释一下，如果感觉理解上有点困难，可以先去了解一下之前推荐的两篇博文，那里会介绍的更加详细一点。

1.最左侧其实就是一个普通的数组，数组的大小必须是2的倍数，这个原因是什么呢？因为这个数组的存放方式是散列的，意思就是需要key.hashcode & (length -1)才能得出存放位置的方式，hash的好处是可以根据key值，在时间复杂度为O(1)的前提找到对应的存放位置，这也是我们的初衷，说到这里其实还没有解释为什么一定要是2的倍数，因为2的倍数-1，这个数的二进制，一定全是1，比如16-1=15，二进制表示就是1111，&运算符其实就是将值全部化成二进制逐位与，比如10111011 & 1111 = 1011 = 11，但是如果不是2的倍数，比如7-1=6，化成二进制就是0110，由于末位是0，不管什么二进制值与0110做&运算，一定是偶数，这样会导致散列分布不均匀。

2.不同key值，相同hash值，如何存放呢？相同的hash值做与运算一定能够得到相同的数组脚标，这些结点，以单链表的形式存在，就是图中数组右侧的单链表。

3.如何实现按访问顺序？上图除去数组和挂在数组右侧的单链表，还有绿色和黄色的单向箭头，在右上角还有一个双向链表的头指针。其实这些箭头就是维护不同结点的访问顺序，即双向链表。

总上所述，这种数据结构定义的结构体如下：
class Node
Object key; //存放key值，用于计算存放数组脚标位置
Object value;//存放元素值
int hash;//存放key.hashcode
Node next;//维护单链表顺序
Node before;//维护双向链表顺序
Node after;


笔者用java实现如下，感兴趣可以用自己喜欢的语言去实现一遍，加深理解：

其实以上实现底层原理就是LinkedHashMap的实现原理，只不过笔者做了一些简化，去掉了繁琐的继承，扩容等，突出了算法核心，如果读者感兴趣也可以去研究一下LinkedHashMap的源码。

使用LinkedHashMap来实现LRU算法：

看起来是不是简单了很多，因为LinkedHashMap底层已经封装好了，我们直接调用就好，但是作为一个想要变优秀的码农，一定要知其然知其所以然。

使用散列+双向链表的方式是如何实现O(1)复杂度的？在实现LRU算法过程中，无非两种操作，查找和修改，使用散列数组实现查找时间复杂度为O(1)，使用双向链表实现修改复杂度为O(1)，并且双向链表还可以维护访问顺序，所以使用这种方式，可以达到O(1)。

缓存淘汰算法-LRU 实现原理

01、前言

我们常用缓存提升数据查询速度，由于缓存容量有限，当缓存容量到达上限，就需要删除部分数据挪出空间，这样新数据才可以添加进来。缓存数据不能随机删除，一般情况下我们需要根据某种算法删除缓存数据。常用淘汰算法有 LRU,LFU,FIFO,这篇文章我们聊聊 LRU 算法。

02、LRU 简介

LRU 是 Least Recently Used 的缩写，这种算法认为最近使用的数据是热门数据，下一次很大概率将会再次被使用。而最近很少被使用的数据，很大概率下一次不再用到。当缓存容量的满时候，优先淘汰最近很少使用的数据。

假设现在缓存内部数据如图所示：

这里我们将列表第一个节点称为头结点，最后一个节点为尾结点。

当调用缓存获取 key=1 的数据，LRU 算法需要将 1 这个节点移动到头结点，其余节点不变，如图所示。
 

然后我们插入一个 key=8 节点，此时缓存容量到达上限，所以加入之前需要先删除数据。由于每次查询都会将数据移动到头结点，未被查询的数据就将会下沉到尾部节点，尾部的数据就可以认为是最少被访问的数据，所以删除尾结点的数据。

然后我们直接将数据添加到头结点。

这里总结一下 LRU 算法具体步骤：

• 新数据直接插入到列表头部
• 缓存数据被命中，将数据移动到列表头部
• 缓存已满的时候，移除列表尾部数据。

03、LRU 算法实现

上面例子中可以看到，LRU 算法需要添加头节点，删除尾结点。而链表添加节点/删除节点时间复杂度 O(1)，非常适合当做存储缓存数据容器。但是不能使用普通的单向链表，单向链表有几点劣势:

1. 每次获取任意节点数据，都需要从头结点遍历下去，这就导致获取节点复杂度为 O(N)。
2. 移动中间节点到头结点，我们需要知道中间节点前一个节点的信息，单向链表就不得不再次遍历获取信息。

针对以上问题，可以结合其他数据结构解决。

使用散列表存储节点，获取节点的复杂度将会降低为 O(1)。节点移动问题可以在节点中再增加前驱指针，记录上一个节点信息，这样链表就从单向链表变成了双向链表。

综上使用双向链表加散列表结合体，数据结构如图所示:

 

在双向链表中特意增加两个『哨兵』节点，不用来存储任何数据。使用哨兵节点，增加/删除节点的时候就可以不用考虑边界节点不存在情况，简化编程难度，降低代码复杂度。

LRU 算法实现代码如下，为了简化 key ，val 都认为 int 类型。

public class LRUCache 

    Entry head, tail;
    int capacity;
    int size;
    Map<Integer, Entry> cache;


    public LRUCache(int capacity) 
        this.capacity = capacity;
        // 初始化链表
        initLinkedList();
        size = 0;
        cache = new HashMap<>(capacity + 2);
    

    /**
     * 如果节点不存在，返回 -1.如果存在，将节点移动到头结点，并返回节点的数据。
     *
     * @param key
     * @return
     */
    public int get(int key) 
        Entry node = cache.get(key);
        if (node == null) 
            return -1;
        
        // 存在移动节点
        moveToHead(node);
        return node.value;
    

    /**
     * 将节点加入到头结点，如果容量已满，将会删除尾结点
     *
     * @param key
     * @param value
     */
    public void put(int key, int value) 
        Entry node = cache.get(key);
        if (node != null) 
            node.value = value;
            moveToHead(node);
            return;
        
        // 不存在。先加进去，再移除尾结点
        // 此时容量已满 删除尾结点
        if (size == capacity) 
            Entry lastNode = tail.pre;
            deleteNode(lastNode);
            cache.remove(lastNode.key);
            size--;
        
        // 加入头结点

        Entry newNode = new Entry();
        newNode.key = key;
        newNode.value = value;
        addNode(newNode);
        cache.put(key, newNode);
        size++;

    

    private void moveToHead(Entry node) 
        // 首先删除原来节点的关系
        deleteNode(node);
        addNode(node);
    

    private void addNode(Entry node) 
        head.next.pre = node;
        node.next = head.next;

        node.pre = head;
        head.next = node;
    

    private void deleteNode(Entry node) 
        node.pre.next = node.next;
        node.next.pre = node.pre;
    


    public static class Entry 
        public Entry pre;
        public Entry next;
        public int key;
        public int value;

        public Entry(int key, int value) 
            this.key = key;
            this.value = value;
        

        public Entry() 
        
    

    private void initLinkedList() 
        head = new Entry();
        tail = new Entry();

        head.next = tail;
        tail.pre = head;

    

    public static void main(String[] args) 

        LRUCache cache = new LRUCache(2);

        cache.put(1, 1);
        cache.put(2, 2);
        System.out.println(cache.get(1));
        cache.put(3, 3);
        System.out.println(cache.get(2));

    

04、LRU 算法分析

缓存命中率是缓存系统的非常重要指标，如果缓存系统的缓存命中率过低，将会导致查询回流到数据库，导致数据库的压力升高。

结合以上分析 LRU 算法优缺点。

LRU 算法优势在于算法实现难度不大，对于对于热点数据， LRU 效率会很好。

LRU 算法劣势在于对于偶发的批量操作，比如说批量查询历史数据，就有可能使缓存中热门数据被这些历史数据替换，造成缓存污染，导致缓存命中率下降，减慢了正常数据查询。

05、LRU 算法改进方案

以下方案来源与 MySQL InnoDB LRU 改进算法

将链表拆分成两部分，分为热数据区，与冷数据区，如图所示。

改进之后算法流程将会变成下面一样:

1. 访问数据如果位于热数据区，与之前 LRU 算法一样，移动到热数据区的头结点。
2. 插入数据时，若缓存已满，淘汰尾结点的数据。然后将数据插入冷数据区的头结点。
3. 处于冷数据区的数据每次被访问需要做如下判断：若该数据已在缓存中超过指定时间，比如说 1 s，则移动到热数据区的头结点。若该数据存在在时间小于指定的时间，则位置保持不变。

对于偶发的批量查询，数据仅仅只会落入冷数据区，然后很快就会被淘汰出去。热门数据区的数据将不会受到影响，这样就解决了 LRU 算法缓存命中率下降的问题。

其他改进方法还有 LRU-K，2Q,LIRS 算法，感兴趣同学可以自行查阅。