Redis的lru算法

LRU：least Recently Used的缩写，最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的数据予以淘汰。

package com.example.demo.algorithm;

import software.amazon.awssdk.services.emr.model.HadoopStepConfig;

import java.util.HashMap;
import java.util.LinkedHashMap;

/**
 * LRU最近最早被删除
 * LRU1
 * @author Ric
 */
public class LruOneDemo {
    /**
     * hash负责查找 创建Node节点作为载体，底部构成双向连接的结构
     */
    class Node<K,V>{
        K key;
        V value;
        Node<K,V> pre;
        Node<K,V> next;

        public Node(){
            this.pre=this.next=null;
        }
        
        public Node(K key,V value){
            this.key = key;
            this.value = value;
            this.pre = this.next = null;
        }
    }
    class LinkedList<K,V>{
        Node<K,V> head;
        Node<K,V> tail;
        
        public LinkedList(){
            head = null ;
            tail = null;
        }

        /**
         * 往头部添加Node节点
         */
        public void addHeadNode(Node<K,V> node){
            node.next = head.next;
            node.pre = head;
            head.next.pre = node;
            head.next = node;
        }

        /**
         * 删除一个节点
         * @param node
         */
        public void deleteNode(Node<K,V> node){
            node.next.pre = node.pre;
            node.pre.next = node.next;
            node.pre = null;
            node.next = null;
        }

        /**
         * 获取最后一个节点
         * @return
         */
        public Node<K,V> getLastNode(){
            return tail.pre;
        }
    }
    private int cacheSize;
    private HashMap<Integer,Node<Integer,Integer>> hashMap;
    private LinkedList<Integer,Integer> linkedList;
    
    public LruOneDemo(int cacheSize){
        this.cacheSize = cacheSize;
        hashMap = new HashMap<>();
        linkedList = new LinkedList<>();
    }

    /**
     * 最新的数据添加到队列的头部
     *
     * 先判断Node里面是否存在 该key
     * 如果存在，先将map的node取出
     * 再删除链表中当前Node的位置
     * 再把当前的Node添加到队列的头部
     * @return
     */
    public Integer get(Integer key){
        if(!hashMap.containsKey(key)){
            return -1;
        }
        Node<Integer, Integer> node = hashMap.get(key);
        linkedList.deleteNode(node);
        linkedList.addHeadNode(node);
        return node.value;
    }

    /**
     * 添加数据
     * 先判断LinkedList是否已经存在饱和的状态
     * 饱和：容量已经满了，需要删除最久未使用的Node，tail的pre队列
     *      再把最新的数据添加到链表头部
        不饱和的话，直接把最新的数据添加到链表头部
     * @param key
     * @param value
     */
    public void put(Integer key,Integer value){
        if (hashMap.containsKey(key)){
            Node<Integer, Integer> node = hashMap.get(key);
            //先删除 后添加
            linkedList.deleteNode(node);
            //更新hash的值
            node.value = value;
            hashMap.put(key,node);
            linkedList.addHeadNode(node);
            return;
        }
        Node<Integer, Integer> integerNode = new Node<>(key, value);
        if(hashMap.size() < cacheSize){
            //不饱和状态
            //找到最久未被使用的Node，并进行删除
            Node<Integer, Integer> node = linkedList.getLastNode();
            linkedList.deleteNode(node);
            hashMap.remove(node.key);
        }
        //添加到队列头，同步到hashMap
        linkedList.addHeadNode(integerNode);
        hashMap.put(key,integerNode);
    }
    
    
    /**
     *  initialCapacity the initial capacity
     *  loadFactor      the load factor
     *  accessOrder     the ordering mode - <tt>true</tt> for  access-order  访问顺序
     *                                      <tt>false</tt> for insertion-order  插入顺序
     * @param args
     */
    public static void main(String[] args) {
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String,Integer>(3,0.75f,false);
    }
}