LRU 缓存淘汰算法的两种实现

It's always the attention to detail and the little grace notes that really make something sing. 专一细节愈出彩，别致心思定成败。

本文主要分享了LRU 缓存淘汰算法两种实现。重要的不是实现，并且思想！

全部源码均已上传至github：连接

定义

LRU（Least Recently Used）最近最少使用策略就像它的名字同样，是根据数据的历史访问记录来进行淘汰数据的，其思想是“若是数据最近被访问过，那么未来被访问的概率也更高；长期不被使用的数据在未来用到的概率也不大；当数据所占内存达到必定的阈值时，将移除最近最少被使用的数据”。

举例

好比一个书柜（容量为10),我会把我本身的书籍放进去，其中有两本书籍是我最喜欢的，常常翻阅，可是随着个人购买，书柜会逐渐放满（内存溢出），这时候就须要用到LRU的思想了，把我不常常看的，从书柜里拿出，放进箱子里，而后再把新买的书籍放进书柜。

再 好比Redis，它是基于内存的，可是内存也不是无穷大的，当内存占用达到一个阈值的时候，它就可使用LRU等一系列缓存算法，或者是将数据存到硬盘里。

具体的实现代码以下：

基于链表

链表初始化，申请capacity大小的内存空间

private LRUByLinkedList(int capacity) {
        head = null;
        size = capacity;
        count = 0;
    }复制代码

模拟LRU的访问（若是没有该数据，则插入头部）

注意：该if-else语句不能交换顺序，不然会出现链表已满，而且该数据已存在的状况没法处理。

private void insert(int data) {
        Node preNode = findNode(data);
        if (null != preNode) {
            delete(preNode);
        } else {
            if (count >= size) {//链表满
                deleteToTail();
            }
        }
        insertToHead(data);
    }复制代码

删除指定数据方法，常规删除

private void delete(Node preNode) {
        System.out.println("删除指定元素：" + preNode.next.data);
        preNode.next = preNode.next.next;
        --count;
    }复制代码

删除链表尾部数据

private void deleteToTail() {
        Node node = head;
        Node curNode = null;
        while (null != node.next) {
            curNode = node;
            node = node.next;
        }
        if (null != curNode) {
            System.out.println("链表已满，删除尾部元素：" + curNode.next.data);
            curNode.next = null;
        }
        --count;
    }复制代码

在头部插入数据

private void insertToHead(int data) {
        Node node = new Node(data, null);
        if (null == head) {
            head = node;
        } else {
            node.next = head;
        }
        head = node;
        ++count;
    }
复制代码

测试结果以下

1. 首先将capacity大小的链表插满
   
2. 当插入capacity+1个数据时，须要删除尾部数据
   
3. 当插入的数据存在的时候，将它从其位置删除，而且插入头部
   

基于数组

数据比较链表实现起来更为简单，在此不作阐述，直接上代码。

private LRUByArray(int capacity) {
        arrays = new int[capacity];
        size = capacity;
        count = 0;
    }复制代码

private void insert(int data) {
        int index = findValue(data);
        if (-1 != index) {
            delete(index);
        } else {
            if (count >= size) {//数组满
                deleteToTail();
            }
        }
        insertToHead(data);
    }复制代码

private void delete(int index) {
        //经过数据迁移的方式将该值删除
        for (int i = index + 1; i < count; i++) {
            arrays[i - 1] = arrays[i];
        }
        System.out.println("删除元素...");
        --count;
    }复制代码

private void deleteToTail() {
        --count;//标记删除法，实际上数组还存有该元素
        System.out.println("删除尾部元素...");
    }复制代码

private void insertToHead(int data) {
        if (count > 1) {
            for (int i = count - 1; i > -1; --i) {
                arrays[i + 1] = arrays[i];
            }
        }
        arrays[0] = data;
        ++count;
    }复制代码

测试结果以下

注意：由于有大量频繁的访问致使数据迁移频繁，所以数组并不适合作这种事情，能够考虑加一个HaspMap作缓存，避免数据的频繁迁移。

end

您的点赞和关注是对我最大的支持，谢谢！