LRU(Least Recently Used)算法简单介绍

LRU算法简介

LRU英文翻译过来就是least recently used,字面意思就是最近最少使用，说白了就是一种淘汰算法，当有新的元素插入进来的时候，我们的使用空间又是有限的时候，就需要淘汰旧的元素，这时候就会选择淘汰最近最少使用的元素。

使用场景

我们实现一个功能就是登陆的时候会保存每个user的ip,首先这个ip会插入数据库里面，系统启动的时候会更新到缓存里面，如果所以每次用户登陆的时候我们会先查询缓存里面是否有这个user,如果没有再查询数据库，如果数据库没有就会请求api查询这个user的ip然后更新到缓存跟数据库，随着user的增加缓存的数量也会增加，这样就会非常的耗内存，所以我们会制定一定数量的内存然后存取一定数量的user,然后就会面临着一个淘汰的机制，这个时候LRU算法就派上了用场。

简单实现

/**
 * Created by dc on 2019/6/29.
 * lru算法 least recently userd 最近最少使用的数据
 */
public class LruMap {

    /**
     * 头部节点，最后被使用的数据
     */
    private Node head;
    /**
     * 尾部节点，最近最少被使用的节点
     */
    private Node tail;
    /**
     * 存储数量
     */
    private int limit;

    private Map data;

    public LruMap(int limit) {
        this.data = new HashMap<>();
        this.limit = limit;
    }

    /**
     * 插入数据
     * @param key
     * @param value
     */
    public void put(String key, String value) {
        Node node = data.get(key);
        if(node == null) {
            if(data.size() >= limit) {
                String oldKey = removeNode(tail);
                data.remove(oldKey);
            }
            Node node1 = new Node(key,value);
            addNode(node1);
            data.put(key, node1);
        }else {
            node.value = value;
            refresh(node);
        }
    }

    /**
     * 获取数据
     * @param key
     * @return
     */
    public String get(String key) {
        Node node = data.get(key);
        if(node == null ){
            return null;
        }else {
            refresh(node);
            return node.value;
        }
    }

    /**
     * 更新节点
     * @param node
     */
    private void refresh(Node node) {
        if(node == head) {
            return;
        }
        removeNode(node);
        addNode(node);
    }

    /**
     * 添加节点
     * @param node
     */
    private void addNode(Node node) {
        if (head != null) {
            node.next = head;
            head.pre = node;
        }
        head = node;
        if(tail == null) {
            tail = node;
        }
    }

    /**
     * 删除几点
     * @param node
     * @return
     */
    private String removeNode(Node node) {
        if(node == tail){
            tail = tail.pre;
        }else if(node == head) {
            head = head.next;
        }else{
            node.pre.next = node.next;
            node.next.pre = node.pre;
        }
      return node.key;
    }

    class Node{

        public Node(String key, String value) {
            this.key = key;
            this.value = value;
        }

        private Node pre;
        private Node next;
        private String key;
        private String value;


    }

    public static void main(String[] args) {

        LruMap lruMap = new LruMap(5);
        lruMap.put("001","用户001的信息");
        lruMap.put("002","用户002的信息");
        lruMap.put("003","用户003的信息");
        lruMap.put("004","用户004的信息");
        lruMap.put("005","用户005的信息");

        lruMap.get("001");
        lruMap.put("006","用户006的信息");
        System.out.println(lruMap.get("002"));



    }

简单介绍

主要是基于hashmap+双向链表，就是linkedhashmap,我只是手写了一个简单的，原理就是相当于一个堆，先进后出的原理，最后插入的元素或者最近访问过的元素都会在最上面，当存储不够的时候就会淘汰最下面的元素。