—————  两个月前  —————

用户信息当然是存在数据库里。但是由于我们对用户系统的性能要求比较高，显然不能每一次请求都去查询数据库。

所以，小灰在内存中创建了一个哈希表作为缓存，每次查找一个用户的时候先在哈希表中查询，以此提高访问性能。

很快，用户系统上线了，小灰美美地休息了几天。

一个多月之后......

———————————————

什么是哈希链表呢？

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

在哈希链表当中，这些Key-Value不再是彼此无关的存在，而是被一个链条串了起来。每一个Key-Value都具有它的前驱Key-Value、后继Key-Value，就像双向链表中的节点一样。

这样一来，原本无序的哈希表拥有了固定的排列顺序。

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

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

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

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

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

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

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

1. private Node head;

2. private Node end;

3. //缓存存储上限

4. private int limit;


5. 
   

6. 
   

7. private HashMap<String, Node> hashMap;


8. 
   

9. 
   

10. public LRUCache(int limit) {

11.    this.limit = limit;

12.    hashMap = new HashMap<String, Node>();

13. }


14. 
    

15. 
    

16. public String get(String key) {

17.    Node node = hashMap.get(key);

18.    if (node == null){

19.        return null;

20.    }

21.    refreshNode(node);

22.    return node.value;

23. }


24. 
    

25. 
    

26. public void put(String key, String value) {

27.    Node node = hashMap.get(key);

28.    if (node == null) {

29.        //如果key不存在，插入key-value

30.        if (hashMap.size() >= limit) {

31.            String oldKey = removeNode(head);

32.            hashMap.remove(oldKey);

33.        }

34.        node = new Node(key, value);

35.        addNode(node);

36.        hashMap.put(key, node);

37.    }else {

38.        //如果key存在，刷新key-value

39.        node.value = value;

40.        refreshNode(node);

41.    }

42. }


43. 
    

44. 
    

45. public void remove(String key) {

46.    Node node = hashMap.get(key);

47.    removeNode(node);

48.    hashMap.remove(key);

49. }


50. 
    

51. 
    

52. /**

53. * 刷新被访问的节点位置

54. * @param  node 被访问的节点

55. */

56. private void refreshNode(Node node) {

57.    //如果访问的是尾节点，无需移动节点

58.    if (node == end) {

59.        return;

60.    }

61.    //移除节点

62.    removeNode(node);

63.    //重新插入节点

64.    addNode(node);

65. }


66. 
    

67. 
    

68. /**

69. * 删除节点

70. * @param  node 要删除的节点

71. */



72. private String removeNode(Node node) {

73.    if (node == end) {

74.        //移除尾节点

75.        end = end.pre;

76.    }else if(node == head){

77.        //移除头节点

78.        head = head.next;

79.    } else {

80.        //移除中间节点

81.        node.pre.next = node.next;

82.        node.next.pre = node.pre;

83.    }

84.    return node.key;

85. }


86. 
    

87. 
    

88. /**

89. * 尾部插入节点

90. * @param  node 要插入的节点

91. */

92. private void addNode(Node node) {

93.    if(end != null) {

94.        end.next = node;

95.        node.pre = end;

96.        node.next = null;

97.    }

98.    end = node;

99.    if(head == null){

100.        head = node;

101.    }

102. }


103. 
     

104. 
     

105. class Node {

106.    Node(String key, String value){

107.        this.key = key;

108.        this.value = value;

109.    }

110.    public Node pre;

111.    public Node next;

112.    public String key;

113.    public String value;

114. }


115. 
     

116. 
     

117. public static void main(String[] args) {

118.    LRUCache lruCache = new LRUCache(5);

119.    lruCache.put("001", "用户1信息");

120.    lruCache.put("002", "用户1信息");

121.    lruCache.put("003", "用户1信息");

122.    lruCache.put("004", "用户1信息");

123.    lruCache.put("005", "用户1信息");

124.    lruCache.get("002");

125.    lruCache.put("004", "用户2信息更新");

126.    lruCache.put("006", "用户6信息");

127.    System.out.println(lruCache.get("001"));

128.    System.out.println(lruCache.get("006"));

129. }

130. 
     

需要注意的是，这段不是线程安全的，要想做到线程安全，需要加上synchronized修饰符。

告诉大家一个好消息，小灰的《漫画算法》全面上架啦，在短短的两周里，本书一度霸占着各大畅销榜榜首！

扫码查看详情

小灰把两年多以来积累的漫画作品进行了筛选和优化，并加上了一些更为基础和系统的入门章节，最终完成了本书的六大篇章：

第一章 算法概述

介绍了算法和数据结构的相关概念，告诉大家算法是什么，数据结构又是什么，它们有哪些用途，如何分析时间复杂度，如何分析空间复杂度。

第二章 数据结构基础

介绍了最基本的数据结构，包括数组、链表、栈、队列、哈希表的概念和读写操作。

第三章 树

介绍了树和二叉树的概念、二叉树的各种遍历方式、二叉堆和优先队列的应用。

第四章 排序算法

介绍了几种典型的排序算法，包括冒泡排序、快速排序、堆排序、计数排序、桶排序。

第五章 面试中的算法

介绍了10余道职场上流行的算法面试题及详细的解题思路。例如怎样判断链表有环、怎样计算大整数相加等。

第六章 算法的实际应用

介绍了算法在职场上的一些应用，例如使用LRU算法来淘汰冷数据，使用Bitmap算法来统计用户特征等。

本书是全彩印制，书中的每一章、每一节、每一句话、每一幅图、每一行代码，都经过了小灰和编辑们的精心打磨，力求用最为直白的方式把知识讲明白、讲透彻。

早期的漫画中存在一些叙述错误和表达不清晰的地方，小灰在本书中做了修正和补充；同时书中增加了许多全新的篇章，使得本书的内容更加系统和全面。

对于渴望学习算法的小伙伴，无论你是正在学习计算机专业的学生，还是已经进入职场的新人，亦或是拥有多年工作经验却不擅长算法的老手，这本《漫画算法》都能帮助你告别对算法的恐惧，认识算法、掌握算法。

扫码购买

新品8折优惠中