LRU算法缓存淘汰策略

妖狐艹你老母 2023-02-13 12:30 13阅读 0赞

### LRU算法是什么？ ###

按照英文的直接原义就是Least Recently Used,最近最久未使用法，它是按照一个非常著名的计算机操作系统基础理论得来的：最近使用的页面数据会在未来一段时期内仍然被使用,已经很久没有使用的页面很有可能在未来较长的一段时间内仍然不会被使用

基于这个思想, 会存在一种缓存淘汰机制，每次从内存中找到最久未使用的数据然后置换出来，从而存入新的数据！它的主要衡量指标是使用的时间，附加指标是使用的次数。

在计算机中大量使用了这个机制，它的合理性在于优先筛选热点数据，所谓热点数据，就是最近最多使用的数据！因为，利用LRU我们可以解决很多实际开发中的问题，并且很符合业务场景

### LRU原理 ###

可以用一个特殊的栈来保存当前正在使用的各个页面的页面号。当一个新的进程访问某页面时，便将该页面号压入栈顶，其他的页面号往栈底移，如果内存不够，则将栈底的页面号移除。这样，栈顶始终是最新被访问的页面的编号，而栈底则是最近最久未访问的页面的页面号。

###### 基于HashMap和双向链表的LRU ######

下面展示了，预设大小是 3 的，LRU存储的在存储和访问过程中的变化。为了简化图复杂度，图中没有展示 HashMap部分的变化，仅仅演示了上图 LRU 双向链表的变化。而且save()和get（）的时间复杂的都是O（1）我们对这个LRU缓存的操作序列如下：

save(“key1”, 7)

save(“key2”, 0)

save(“key3”, 1)

save(“key4”, 2)

get(“key2”)

save(“key5”, 3)

get(“key2”)

save(“key6”, 4)

相应的 LRU 双向链表部分变化如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTEzNDMw_size_16_color_FFFFFF_t_70]  
总结一下核心操作的步骤:

1，save(key, value)，首先在 HashMap 找到 Key 对应的节点，如果节点存在，更新节点的值，并把这个节点移动队头。如果不存在，需要构造新的节点，并且尝试把节点塞到队头，如果LRU空间不足，则通过 tail 淘汰掉队尾的节点，同时在 HashMap 中移除 Key。  
2，get(key)，通过 HashMap 找到 LRU 链表节点，把节点插入到队头，返回缓存的值

###### Java代码的实现 ######

class DLinkedNode {
        
    	String key;
    	int value;
    	DLinkedNode pre;
    	DLinkedNode post;
    }

LRU Cache

public class LRUCache {
        
       
        private Hashtable<Integer, DLinkedNode>
                cache = new Hashtable<Integer, DLinkedNode>();
        private int count;
        private int capacity;
        private DLinkedNode head, tail;
     
        public LRUCache(int capacity) {
        
            this.count = 0;
            this.capacity = capacity;
     
            head = new DLinkedNode();
            head.pre = null;
     
            tail = new DLinkedNode();
            tail.post = null;
     
            head.post = tail;
            tail.pre = head;
        }
     
        public int get(String key) {
        
     
            DLinkedNode node = cache.get(key);
            if(node == null){
        
                return -1; // should raise exception here.
            }
     
            // move the accessed node to the head;
            this.moveToHead(node);
     
            return node.value;
        }
     
     
        public void set(String key, int value) {
        
            DLinkedNode node = cache.get(key);
     
            if(node == null){
        
     
                DLinkedNode newNode = new DLinkedNode();
                newNode.key = key;
                newNode.value = value;
     
                this.cache.put(key, newNode);
                this.addNode(newNode);
     
                ++count;
     
                if(count > capacity){
        
                    // pop the tail
                    DLinkedNode tail = this.popTail();
                    this.cache.remove(tail.key);
                    --count;
                }
            }else{
        
                // update the value.
                node.value = value;
                this.moveToHead(node);
            }
        }
        /**
         * Always add the new node right after head;
         */
        private void addNode(DLinkedNode node){
        
            node.pre = head;
            node.post = head.post;
     
            head.post.pre = node;
            head.post = node;
        }
     
        /**
         * Remove an existing node from the linked list.
         */
        private void removeNode(DLinkedNode node){
        
            DLinkedNode pre = node.pre;
            DLinkedNode post = node.post;
     
            pre.post = post;
            post.pre = pre;
        }
     
        /**
         * Move certain node in between to the head.
         */
        private void moveToHead(DLinkedNode node){
        
            this.removeNode(node);
            this.addNode(node);
        }
     
        // pop the current tail.
        private DLinkedNode popTail(){
        
            DLinkedNode res = tail.pre;
            this.removeNode(res);
            return res;
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTEzNDMw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/202005291446411.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTEzNDMw,size_16,color_FFFFFF,t_70