LRU全称Least Recently Used，也就是最近最少使用的意思，是一种内存管理算法，该算法最早应用于Linux操作系统。
    这个算法基于一种假设：长期不被使用的数据，在未来被用到的几率也不大。因此，当数据所占内存达到一定阈值时，我们要移除掉最近最少被使用的数据。
    可以使用哈希链表来实现LRU算法。

    我们需要抽出一个用户系统，向各个业务系统提供用户的基本信息。

    以用户信息的需求为例，来演示一下LRU算法的基本思路。

    1. 假设使用哈希链表来缓存用户信息，目前缓存了4个用户，这4个用户是按照被访问的时间顺序依次从链表右端插入的。

    image.png

    1. 如果这时业务方访问用户5，由于哈希链表中没有用户5的数据，需要从数据库中读取出来，插入到缓存中。此时，链表最右端是最新被访问的用户5，最左端是最近最少被访问的用户1。

    image.png

    1. 接下来，如果业务方访问用户2，哈希链表中已经存在用户2的数据，这时我们把用户2从它的前驱节点和后继节点之间移除，重新插入链表的最右端。此时，链表的最右端变成了最新被访问的用户2，最左端仍然是最近最少被访问的用户1。

    image.png

    1. 接下来，如果业务方请求修改用户4的信息。同样的道理，我们会把用户4从原来的位置移动到链表的最右侧，并把用户信息的值更新。这时，链表的最右端是最新被访问的用户4，最左端仍然是最近最少被访问的用户1。

    image.png

    1. 后来业务方又要访问用户6，用户6在缓存里没有，需要插入哈希链表中。假设这时缓存容量已经达到上限，必须先删除最近最少被访问的数据，那么位于哈希链表最左端的用户1就会被删除，然后再把用户6插入最右端的位置。

    image.png
    以上，就是LRU算法的基本思路。

    1. class Node {
    2.     public Node pre;
    3.     public Node next;
    4.     public String key;
    5.     public String value;
    7.     public Node(String key, String value) {
    8.         this.key = key;
    9.         this.value = value;
    10.     }
    11. }
    13. public class LRUCache {
    15.     private Node head;
    16.     private Node end;
    17.     // 缓存存储上限
    18.     private int limit;
    20.     private HashMap<String, Node> hashMap;
    22.     // 删除节点
    23.     private String removeNode(Node node) {
    24.         if (node == head && node == end) {
    25.             // 移除唯一的节点
    26.             head = null;
    27.             end = null;
    28.         } else if (node == end) {
    29.             // 移除尾结点
    30.             end = end.pre;
    31.             end.next = null;
    32.         } else if (node == head) {
    33.             // 移除头节点
    34.             head = head.next;
    35.             head.pre = null;
    36.         } else {
    37.             // 移除中间节点
    38.             node.pre.next = node.next;
    39.             node.next.pre = node.pre;
    40.         }
    41.         return node.key;
    42.     }
    44.     // 尾部插入节点
    45.     private void addNode(Node node) {
    46.         if (end != null) {
    47.             end.next = node;
    48.             node.pre = end;
    49.             node.next = null;
    50.         }
    51.         end = node;
    52.         if (head == null) {
    53.             head = node;
    54.         }
    55.     }
    57.     // 刷新被访问节点位置
    58.     private void refreshNode(Node node) {
    59.         // 如果访问的是尾节点，则无需移动节点
    60.         if (node == end) return;
    61.         // 移除节点
    62.         removeNode(node);
    63.         // 重新插入节点
    64.         addNode(node);
    65.     }
    67.     public LRUCache(int limit) {
    68.         this.limit = limit;
    69.         hashMap = new HashMap<String, Node>();
    70.     }
    72.     public String get(String key) {
    73.         Node node = hashMap.get(key);
    74.         if (node == null) return null;
    75.         refreshNode(node);
    76.         return node.value;
    77.     }
    79.     public void put(String key, String value) {
    80.         Node node = hashMap.get(key);
    81.         if (node == null) {
    82.             // 如果 key 不存在，则插入 key-value
    83.             if (hashMap.size() >= limit) {
    84.                 String oldKey = removeNode(head);
    85.                 hashMap.remove(oldKey);
    86.             }
    87.             node = new Node(key, value);
    88.             addNode(node);
    89.             hashMap.put(key, node);
    90.         } else {
    91.             // 如果 key 存在，则刷新 key-value
    92.             node.value = value;
    93.             refreshNode(node);
    94.         }
    95.     }
    97.     public void remove(String key) {
    98.         Node node = hashMap.get(key);
    99.         removeNode(node);
    100.         hashMap.remove(key);
    101.     }
    103.     public static void main(String[] args) {
    104.         LRUCache lruCache = new LRUCache(5);
    105.         lruCache.put("001", "用户1");
    106.         lruCache.put("002", "用户2");
    107.         lruCache.put("003", "用户3");
    108.         lruCache.put("004", "用户4");
    109.         lruCache.put("005", "用户5");
    110.         lruCache.get("002");
    111.         lruCache.put("004", "用户44");
    112.         lruCache.put("006", "用户6");
    113.         System.out.println(lruCache.get("001"));
    114.         System.out.println(lruCache.get("006"));
    115.     }
    116. }

    需要注意的是，这段代码不是线程安全的代码，要想做到线程安全，需要加上synchronized修饰符。
    对于用户系统的需求，你也可以使用缓存数据库Redis来实现，Redis底层也实现了类似LRU的回收算法。