【基础算法】Java实现LRU算法

定义：LRU全称Least Recently Used，也就是最近最少使用的意思，是一种内存管理算法，最早应用于Linux系统。

LRU算法基于一种假设：长期不使用的数据，在未来被用到的几率也不大。因此当数据所占内存达到一个阈值是，可以选择移除掉最近最少被使用的数据来保持内存的高效使用，这是基于时间局部性原理的一个假设。LRU算法主要用于缓存算法，在节省资源的情况下提高数据访问效率。

LRU使用了哈希链表来实现。首先介绍哈希表，哈希表是由若干个key-value所组成。在逻辑上，这些key-value没有排列顺序，如下图：

在哈希链表中，key-value对在逻辑上是相互关联的，采用的双向链表的形式组织key-value对，如下图所示：

原本无序的哈希表变成在逻辑上具有前驱和后继的结构。

但是如何使用哈希链表实现LRU算法，如何将这种指向关系转化为时间上的前后呢？我们使用head和end表示链表的头和尾，在时间上先被访问的数据作为双向链表的head，后被访问的数据作为双向链表的end，当达到内存设置大小之后，新进入未被访问过的数据，则将head的节点删除，将新的数据插入end处，如果访问的数据在内存中，则将数据更新到end除，删除原始在的位置。

虽然在java中的LinkedHashMap已经对哈希链表做了很好的实现，但是还是使用HashMap来进行实现。

代码实现

package org.example;
import java.util.HashMap;

/**
 * 双向链表中：head指向最久未访问的元素
 *           end指向最近未访问的元素
 */
public class LRUCache {
    
    

    private Node head;

    private Node end;
    /**
     * 缓存上限
     */
    private int limit;

    private HashMap<String,Node> hashMap;

    public LRUCache(int limit){
    
    
      this.limit = limit;
      hashMap = new HashMap<String,Node>();
    }

    /**
     * 尾部插入节点数据
     * @param node
     */
    private void addNode(Node node){
    
    
        if(end != null){
    
    
           end.setNext(node);
           node.setPre(end);
           node.setNext(null);
        }
        end = node;
        if(head == null){
    
    
            head = node;
        }
    }

    /**
     * 删除节点
     * @param node
     */
    public String removeNode(Node node){
    
    
        if (node == end) {
    
    
            //移除尾节点
            end = end.getPre();
        } else if (node == head) {
    
    
            //移除头结点
            head = head.getNext();
        } else {
    
    
            //移除中间节点
            node.getPre().setNext(node.getNext());
            node.getNext().setPre(node.getPre());
        }
        return node.getKey();
    }

    /**
     * 刷新被访问的节点位置
     * @param node
     */
    private void refreshNode(Node node){
    
    
        //如果访问的是尾节点,即最近未被访问的节点
        if(node==end){
    
    
            return;
        }
        //移除节点
        removeNode(node);
        //重新插入节点
        addNode((node));
    }

    /**
     * 添加节点数据
     */
    public void put(String key,String value){
    
    
        Node node=hashMap.get(key);
        if(node==null){
    
    
            //如果key不存在，插入key-value
            if(hashMap.size()>=limit){
    
    
                String oldKey=removeNode(head);
                hashMap.remove(oldKey);
            }
            node=new Node(key,value);
            addNode(node);
            hashMap.put(key,node);
        }
        else{
    
    
            //如果key存在，刷新key-value
            node.setValue(value);
            refreshNode(node);
        }
    }

    public void remove(String key){
    
    
        Node node=hashMap.get(key);
        removeNode(node);
        hashMap.remove(key);
    }

    /**
     * 查询key对应Node值
     * @param key
     * @return
     */
    public String get(String key){
    
    
        Node node=hashMap.get(key);
        if(node==null){
    
    
            return null;
        }
        refreshNode(node);
        return node.getValue();
    }

    public static void main(String[] args) {
    
    
        LRUCache lruCache=new LRUCache(5);
        lruCache.put("001","用户1信息");
        lruCache.put("002","用户2信息");
        lruCache.put("003","用户3信息");
        lruCache.put("004","用户4信息");
        lruCache.put("005","用户5信息");
        lruCache.get("002");
        lruCache.put("004","用户2信息更新");
        lruCache.put("006","用户6信息");
        System.out.println(lruCache.get("001"));
        System.out.println(lruCache.get("006"));
    }
}
class Node {
    
    
    Node(String key,String value) {
    
    
        this.key = key;
        this.value = value;
    }
    private Node pre;
    private Node next;
    private String key;
    private String value;

    public Node getPre() {
    
    
        return pre;
    }

    public void setPre(Node pre) {
    
    
        this.pre = pre;
    }

    public Node getNext() {
    
    
        return next;
    }

    public void setNext(Node next) {
    
    
        this.next = next;
    }

    public String getKey() {
    
    
        return key;
    }

    public void setKey(String key) {
    
    
        this.key = key;
    }

    public String getValue() {
    
    
        return value;
    }

    public void setValue(String value) {
    
    
        this.value = value;
    }
}

程序运行结果：

程序结果分析：LRU容量设置为5，然后依次插入001-005的信息，lruCache.get(“002”)对key为002的信息进行了刷新，现在哈希链表的时间上顺序为（从左到右依次未被访问时间加长）：001->003->004->005->002，再次对004信息进行更改，更改后顺序为001->003->005->002->004，插入006信息，则顺序为003->005->002->004->006,故最后访问001信息，返回null，访问006，返回用户6信息，同时最后的顺序为：003->005->002->004->006。