lru算法

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

LRU算法基于一种假设，长期不使用的数据，在未来的使用性也不大。因此，当数据占用内存达到一定的阙值时，我们要移除最近最少使用的数据。

LRU算法中，使用了一种有趣的数据结构，叫做哈希链表。

我们都知道，哈希表是由若干个Key-Value所组成，在逻辑上，这些Key-Value是无所谓排列顺序的。

在哈希链表中，这些Key-Value不再是彼此无关的存在，而是被一个链条串联起来，每一个key-Value都有它的前驱和后继Key-value，就像双向链表中的节点一样。这样一来，无序的哈希表拥有了固定的排列顺序。

使用业务场景：

　　需要抽取系统中用户数据，给各个子业务系统使用，子系统对信息的查询频率很高，要注意查询性能。

　　方案一：直接将用户信息放入redis缓存中。

　　方案二：自己写哈希表。虽然在Java 中的LinkedHashMap已经对哈希链表做了很好的实现，但是为了加深印象，还是自己写简单实现。

　　需要注意的是，以下代码并不是线程安全的，在并发情况下可以添加synchronized解决。

package com.ai.channel.lrumap;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

/**
 * @Author zhangliwei
 * @Date 2018/11/5 下午4:02
 */

public class LRUCache {

    private Node head;
    private Node end;
    private int limite;
    private HashMap<String, Node> hashMap ;

    public LRUCache(int limite) {
        this.limite = limite;
        hashMap = new HashMap<>();
    }


    public String get (String key){
        Node node = hashMap.get(key);
        if (null == node){
            return null;
        }
        refreshNode(node);
        return node.value;
    }
    public void put(String key, String value){
        Node node = hashMap.get(key);
        if (null == node){
            if (hashMap.size() >= limite){
                String oldKey = removeNode(head);
                hashMap.remove(oldKey);
            }
            node = new Node(key, value);
            addNode(node);
            hashMap.put(key, node);
        } else {
            node.value = value;
            refreshNode(node);
        }
    }

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

    private void refreshNode(Node node) {
        if (null == node){
            return;
        }
        removeNode(node);
        addNode(node);
    }

    private void addNode(Node node) {
        if (end != null){
            end.next = node;
            node.pre = end;
            node.next = null;
        }
        end = node;
        if (head == null){
            head = node;
        }
    }

    private String removeNode(Node node) {
        if (node == end){
            end = end.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) {
        LRUCache lruCache = new LRUCache(5);
        lruCache.put("1","user001");
        lruCache.put("2","user002");
        lruCache.put("3","user003");
        lruCache.put("4","user004");
        lruCache.put("5","user005");
        lruCache.get("2");
        lruCache.put("4","user004更新");
        lruCache.put("6","user006");
        System.out.println(lruCache.get("1"));
        System.out.println(lruCache.get("6"));

        HashMap<String, Node> hashMap = lruCache.hashMap;
        Set<String> strings = hashMap.keySet();
        Iterator<String> iterator = strings.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next + ": " + hashMap.get(next).value);
        }

    }
}