手写LRU热点缓存数据结构

引言

LRU是开发过程中设计缓存的常用算法，在此基础上，如何设计一个高效的缓存呢？本文就带大家分析并手撸一个LRUCache。

LRU算法

LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。

如何储存

做为缓存，它应该有查询速度快，同时尽可能的修改也快，怎么储存才能查询速度能够保证的情况下，尽可能地提高缓存的修改速度？

使用数组

如果使用数组，可以肯定的是，它的查询速度肯定快，因为它的查询是通过索引下标来进行的，天然速度很快。但是数组大小一旦固定下来，它是不可变的，即使是我们的ArrayList，它要在扩容的时候，效率依然较低。同时如果对数组进行了删除操作，所以的位于被删除结点后面的结点都应该往前移动，它的花销不容小觑。

使用链表

对于链表而言，它的查询速度很慢，因为链表中的查询是通过for遍历来查找的，在最坏的情况下，时间复杂度为O(n)，其中n是指当前链表的长度。虽然java中的LinkedList是通过双向队列来实现的，它的效果也依然较慢

高效LRUCache储存方案

通过对以上问题的思考，要想提高LRUCache的查询修改效率，就必须合理设计其中的数据结构。



本文中，通过HashMap 和 链表组合使用的方式，来提高LRUCache的查询、修改效率。

HashMap中记录着每一个K值，和与之对应的Node结点，如果只是查询，通过map.get(key)操作，能够快速的将结果查询出来，根据LRU理论，如果数据被访问过，那么它将来被再次访问的几率也更高，所以需要将被访问的数据移至尾部（存放最热的数据）

当LRUCache的容量被使用完后，对于冷数据（相对于热点数据）而言，再次插入的时候，应该将冷数据移出，并把刚刚插入的数据加在尾部（热点数据存在于末尾）。也就是所谓的FIFO（先进先出）。

代码实现

Node结点

采用双向队列（前驱结点、后驱结点、当前Node的ket，当前Node的value）

    class Node {
        //前驱结点
        private Node before;
        //当前结点的key值
        private String key;
        //当前结点的value值
        private T value;
        //后驱结点
        private Node after;
    }

LRUCache类

   //头结点
    private String firstKey;

    //尾结点
    private String lastKey;

    //最大容量
    private int capacity;

    /**
     * map
     */
    private Map<String, Node> map;

    /**
     * 构造一个指定容量的LRUCache
     *
     * @param capacity
     */
    public LRUCache(int capacity) {
        this.capacity = capacity;
        map = new HashMap<>(this.capacity);
    }

    /**
     * 构造一个无容量限制的LRUCache
     */
    public LRUCache() {
        this.capacity = Integer.MAX_VALUE;
        map = new HashMap<>();

    }

添加缓存

新添加的缓存作为热点数据放在链尾，当缓存容量不够时，移除头部的非热点数据

 /**
     * 添加或更新缓存
     *
     * @param key   key值
     * @param value 缓存对象
     */
    public void put(String key, T value) {

        Node node = map.get(key);

        if (node == null) {
            if (map.size() >= capacity) {
                this.removeMode();
            }
            node = addNewNode(key);
            node.key = key;
            node.value = value;
            map.put(key, node);

        } else {
            changeNodeToLast(node);
            node.key = key;
            node.value = value;
        }
    }

    /**
     * 添加新结点到末尾
     *
     * @param key key值
     * @return 添加好的结点
     */
    private Node addNewNode(String key) {
        Node newNode = new Node();
        if (firstKey == null) {
            //第一次添加，直接添加到开始位置
            firstKey = key;
        } else if (lastKey == null) {
            //第二次添加，添加到末尾，和head结点互相连接
            lastKey = key;
            Node firstNode = map.get(firstKey);
            newNode.before = firstNode;
            firstNode.after = newNode;
        } else {
            //当头和尾都有Node的时候，添加到末尾
            Node lastNode = map.get(lastKey);
            newNode.before = lastNode;
            lastNode.after = newNode;
            lastKey = key;
        }
        return newNode;
    }

    /**
     * 移除头结点
     */
    private void removeMode() {
        Node firstNode = map.get(firstKey);
        map.remove(firstKey);

        if (firstNode.after != null) {
            firstKey = firstNode.after.key;
            firstNode.after.before = null;
        } else {
            //只有一个结点
            firstKey = null;
            lastKey = null;
        }

    }

查询缓存

对于存在的缓存，经过了一次查询后，应该将其作为热点数据放到链尾

    /**
     * 查询缓存
     *
     * @param key
     * @return
     */
    public T get(String key) {
        Node node = map.get(key);
        if (node != null) {
            changeNodeToLast(node);
            return node.value;
        }
        return null;
    }

    /**
     * 将热点缓存移到尾部
     *
     * @param node
     */
    private void changeNodeToLast(Node node) {
        //如果还没有结点，则node就是firstNode
        if (firstKey == null) {
            firstKey = node.key;
        }
        //判断是否已经是尾结点
        if (lastKey.equals(node.key)) {
            return;
        }

        //判断是否是头结点
        if (firstKey.equals(node.key)) {
            //如果是头结点，而且没有下个结点，则只有一个结点，直接返回
            if (node.after == null) {
                return;
            }
            //如果是是头结点，且存在多个结点
            firstKey = node.after.key;
        }

        Node a = node.after;
        Node b = node.before;

        if (b != null) {
            b.after = a;
        }
        if (a != null) {
            a.before = b;
        }

        Node lastNode = map.get(lastKey);
        lastKey = node.key;

        node.before = lastNode;
        lastNode.after = node;

        lastNode = node;
        lastNode.after = null;
    }

删除缓存

删除的时候，如果删除的正是头结点或尾结点，则需要更改firstKey或lastKey

/**
     * 删除缓存
     *
     * @param key 要删除的缓存key值
     * @return
     */
    public boolean delete(String key) {
        Node removeNode = map.remove(key);
        if (removeNode == null) {
            return false;
        } else {
            Node a = removeNode.after;
            Node b = removeNode.before;
            //如果是头结点需要移动firstKey指针
            if (key.equals(firstKey)) {
                firstKey = a.key;
            } else if (key.equals(lastKey)) {
                //如果是尾结点需要移动lastkey指针
                lastKey = b.key;
            }
            if (a != null) {
                a.before = b;
            }
            if (b != null) {
                b.after = a;
            }
            return true;
        }
    }

完整代码

public class LRUCache<T> {

    class Node {
        //前驱结点
        private Node before;
        //当前结点的key值
        private String key;
        //当前结点的value值
        private T value;
        //后驱结点
        private Node after;
    }

    //头结点
    private String firstKey;

    //尾结点
    private String lastKey;

    //最大容量
    private int capacity;

    /**
     * map
     */
    private Map<String, Node> map;

    /**
     * 构造一个指定容量的LRUCache
     *
     * @param capacity
     */
    public LRUCache(int capacity) {
        this.capacity = capacity;
        map = new HashMap<>(this.capacity);
    }

    /**
     * 构造一个无容量限制的LRUCache
     */
    public LRUCache() {
        this.capacity = Integer.MAX_VALUE;
        map = new HashMap<>();

    }

    /**
     * 添加新结点到末尾
     *
     * @param key key值
     * @return 添加好的结点
     */
    private Node addNewNode(String key) {
        Node newNode = new Node();
        if (firstKey == null) {
            //第一次添加，直接添加到开始位置
            firstKey = key;
        } else if (lastKey == null) {
            //第二次添加，添加到末尾，和head结点互相连接
            lastKey = key;
            Node firstNode = map.get(firstKey);
            newNode.before = firstNode;
            firstNode.after = newNode;
        } else {
            //当头和尾都有Node的时候，添加到末尾
            Node lastNode = map.get(lastKey);
            newNode.before = lastNode;
            lastNode.after = newNode;
            lastKey = key;
        }
        return newNode;
    }

    /**
     * 移除头结点
     */
    private void removeMode() {
        Node firstNode = map.get(firstKey);
        map.remove(firstKey);

        if (firstNode.after != null) {
            firstKey = firstNode.after.key;
            firstNode.after.before = null;
        } else {
            //只有一个结点
            firstKey = null;
            lastKey = null;
        }

    }

    /**
     * 将热点缓存移到尾部
     *
     * @param node
     */
    private void changeNodeToLast(Node node) {
        //如果还没有结点，则node就是firstNode
        if (firstKey == null) {
            firstKey = node.key;
        }
        //判断是否已经是尾结点
        if (lastKey.equals(node.key)) {
            return;
        }

        //判断是否是头结点
        if (firstKey.equals(node.key)) {
            //如果是头结点，而且没有下个结点，则只有一个结点，直接返回
            if (node.after == null) {
                return;
            }
            //如果是是头结点，且存在多个结点
            firstKey = node.after.key;
        }

        Node a = node.after;
        Node b = node.before;

        if (b != null) {
            b.after = a;
        }
        if (a != null) {
            a.before = b;
        }

        Node lastNode = map.get(lastKey);
        lastKey = node.key;

        node.before = lastNode;
        lastNode.after = node;

        lastNode = node;
        lastNode.after = null;
    }
    /**
     * 查询缓存
     *
     * @param key
     * @return
     */
    public T get(String key) {
        Node node = map.get(key);
        if (node != null) {
            changeNodeToLast(node);
            return node.value;
        }
        return null;
    }
    /**
     * 添加缓存
     *
     * @param key   key值
     * @param value 缓存对象
     */
    public void put(String key, T value) {
        Node node = map.get(key);
        if (node == null) {
            if (map.size() >= capacity) {
                this.removeMode();
            }
            node = addNewNode(key);
            node.key = key;
            node.value = value;
            map.put(key, node);

        } else {
            changeNodeToLast(node);
            node.key = key;
            node.value = value;
        }
    }
    /**
     * 删除缓存
     *
     * @param key 要删除的缓存key值
     * @return
     */
    public boolean delete(String key) {
        Node removeNode = map.remove(key);
        if (removeNode == null) {
            return false;
        } else {
            Node a = removeNode.after;
            Node b = removeNode.before;
            //如果是头结点需要移动firstKey指针
            if (key.equals(firstKey)) {
                firstKey = a.key;
            } else if (key.equals(lastKey)) {
                //如果是尾结点需要移动lastkey指针
                lastKey = b.key;
            }
            if (a != null) {
                a.before = b;
            }
            if (b != null) {
                b.after = a;
            }
            return true;
        }
    }
    /**
     * 输出
     */
    public void print() {
        Node node = map.get(firstKey);
        while (node != null) {
            System.out.println(node.value);
            node = node.after;
        }
    }
}

以上代码并未考虑线程安全问题