面試官問：Redis 記憶體滿了怎麼辦？我想不到！

Redis是基于記憶體的key-value資料庫，因為系統的記憶體大小有限，是以我們在使用Redis的時候可以配置Redis能使用的最大的記憶體大小。

1、通過配置檔案配置

通過在Redis安裝目錄下面的redis.conf配置檔案中添加以下配置設定記憶體大小

1. //設定Redis最大占用記憶體大小為100M

2. maxmemory 100mb

3. 複制代碼

redis的配置檔案不一定使用的是安裝目錄下面的redis.conf檔案，啟動redis服務的時候是可以傳一個參數指定redis的配置檔案的

2、通過指令修改

Redis支援運作時通過指令動态修改記憶體大小

1. //設定Redis最大占用記憶體大小為100M

2. 127.0.0.1:6379> config set maxmemory 100mb

3. //擷取設定的Redis能使用的最大記憶體大小

4. 127.0.0.1:6379> config get maxmemory

5. 複制代碼

如果不設定最大記憶體大小或者設定最大記憶體大小為0，在64位作業系統下不限制記憶體大小，在32位作業系統下最多使用3GB記憶體

Redis的記憶體淘汰

既然可以設定Redis最大占用記憶體大小，那麼配置的記憶體就有用完的時候。那在記憶體用完的時候，還繼續往Redis裡面添加資料不就沒記憶體可用了嗎？

實際上Redis定義了幾種政策用來處理這種情況：

noeviction(預設政策)：對于寫請求不再提供服務，直接傳回錯誤（DEL請求和部分特殊請求除外）

allkeys-lru：從所有key中使用LRU算法進行淘汰

volatile-lru：從設定了過期時間的key中使用LRU算法進行淘汰

allkeys-random：從所有key中随機淘汰資料

volatile-random：從設定了過期時間的key中随機淘汰

volatile-ttl：在設定了過期時間的key中，根據key的過期時間進行淘汰，越早過期的越優先被淘汰

當使用volatile-lru、volatile-random、volatile-ttl這三種政策時，如果沒有key可以被淘汰，則和noeviction一樣傳回錯誤

如何擷取及設定記憶體淘汰政策

擷取目前記憶體淘汰政策：

1. 127.0.0.1:6379> config get maxmemory-policy

通過配置檔案設定淘汰政策（修改redis.conf檔案）：

1. maxmemory-policy allkeys-lru

通過指令修改淘汰政策：

1. 127.0.0.1:6379> config set maxmemory-policy allkeys-lru

LRU算法

什麼是LRU?

上面說到了Redis可使用最大記憶體使用完了，是可以使用LRU算法進行記憶體淘汰的，那麼什麼是LRU算法呢？

LRU(Least Recently Used)，即最近最少使用，是一種緩存置換算法。在使用記憶體作為緩存的時候，緩存的大小一般是固定的。當緩存被占滿，這個時候繼續往緩存裡面添加資料，就需要淘汰一部分老的資料，釋放記憶體空間用來存儲新的資料。這個時候就可以使用LRU算法了。其核心思想是：如果一個資料在最近一段時間沒有被用到，那麼将來被使用到的可能性也很小，是以就可以被淘汰掉。

使用java實作一個簡單的LRU算法

1. publicclassLRUCache<k, v> {

2. //容量

1. privateint capacity;

2. //目前有多少節點的統計

3. privateint count;

4. //緩存節點

5. privateMap<k, Node<k, v>> nodeMap;

6. privateNode<k, v> head;

7. privateNode<k, v> tail;

8. publicLRUCache(int capacity) {

9. if(capacity < 1) {

10. thrownewIllegalArgumentException(String.valueOf(capacity));

11. }

12. this.capacity = capacity;

13. this.nodeMap = newHashMap<>();

14. //初始化頭節點和尾節點，利用哨兵模式減少判斷頭結點和尾節點為空的代碼

15. Node headNode = newNode(null, null);

16. Node tailNode = newNode(null, null);

17. headNode.next= tailNode;

18. tailNode.pre = headNode;

19. this.head = headNode;

20. this.tail = tailNode;

21. }

22. publicvoid put(k key, v value) {

23. Node<k, v> node = nodeMap.get(key);

24. if(node == null) {

25. if(count >= capacity) {

26. //先移除一個節點

27. removeNode();

28. }

29. node = newNode<>(key, value);

30. //添加節點

31. addNode(node);

32. } else{

33. //移動節點到頭節點

34. moveNodeToHead(node);

35. }

36. }

37. publicNode<k, v> get(k key) {

38. Node<k, v> node = nodeMap.get(key);

39. if(node != null) {

40. moveNodeToHead(node);

41. }

42. return node;

43. }

44. privatevoid removeNode() {

45. Node node = tail.pre;

46. //從連結清單裡面移除

47. removeFromList(node);

48. nodeMap.remove(node.key);

49. count--;

50. }

51. privatevoid removeFromList(Node<k, v> node) {

52. Node pre = node.pre;

53. Nodenext= node.next;

54. pre.next= next;

55. next.pre = pre;

56. node.next= null;

57. node.pre = null;

58. }

59. privatevoid addNode(Node<k, v> node) {

60. //添加節點到頭部

61. addToHead(node);

62. nodeMap.put(node.key, node);

63. count++;

64. }

65. privatevoid addToHead(Node<k, v> node) {

66. Nodenext= head.next;

67. next.pre = node;

68. node.next= next;

69. node.pre = head;

70. head.next= node;

71. }

72. publicvoid moveNodeToHead(Node<k, v> node) {

73. //從連結清單裡面移除

74. removeFromList(node);

75. //添加節點到頭部

76. addToHead(node);

77. }

78. classNode<k, v> {

79. k key;

80. v value;

81. Node pre;

82. Nodenext;

83. publicNode(k key, v value) {

84. this.key = key;

85. this.value = value;

86. }

87. }

88. }

89. 複制代碼

上面這段代碼實作了一個簡單的LUR算法，代碼很簡單，也加了注釋，仔細看一下很容易就看懂。

LRU在Redis中的實作

近似LRU算法

Redis使用的是近似LRU算法，它跟正常的LRU算法還不太一樣。近似LRU算法通過随機采樣法淘汰資料，每次随機出5（預設）個key，從裡面淘汰掉最近最少使用的key。

可以通過maxmemory-samples參數修改采樣數量：例：maxmemory-samples 10 maxmenory-samples配置的越大，淘汰的結果越接近于嚴格的LRU算法

Redis為了實作近似LRU算法，給每個key增加了一個額外增加了一個24bit的字段，用來存儲該key最後一次被通路的時間。

Redis3.0對近似LRU的優化

Redis3.0對近似LRU算法進行了一些優化。新算法會維護一個候選池（大小為16），池中的資料根據通路時間進行排序，第一次随機選取的key都會放入池中，随後每次随機選取的key隻有在通路時間小于池中最小的時間才會放入池中，直到候選池被放滿。當放滿後，如果有新的key需要放入，則将池中最後通路時間最大（最近被通路）的移除。

當需要淘汰的時候，則直接從池中選取最近通路時間最小（最久沒被通路）的key淘汰掉就行。

LRU算法的對比

我們可以通過一個實驗對比各LRU算法的準确率，先往Redis裡面添加一定數量的資料n，使Redis可用記憶體用完，再往Redis裡面添加n/2的新資料，這個時候就需要淘汰掉一部分的資料，如果按照嚴格的LRU算法，應該淘汰掉的是最先加入的n/2的資料。生成如下各LRU算法的對比圖（[圖檔來源]

你可以看到圖中有三種不同顔色的點：

• 淺灰色是被淘汰的資料
• 灰色是沒有被淘汰掉的老資料
• 綠色是新加入的資料

我們能看到Redis3.0采樣數是10生成的圖最接近于嚴格的LRU。而同樣使用5個采樣數，Redis3.0也要優于Redis2.8。

LFU算法

LFU算法是Redis4.0裡面新加的一種淘汰政策。它的全稱是Least Frequently Used，它的核心思想是根據key的最近被通路的頻率進行淘汰，很少被通路的優先被淘汰，被通路的多的則被留下來。

LFU算法能更好的表示一個key被通路的熱度。假如你使用的是LRU算法，一個key很久沒有被通路到，隻剛剛是偶爾被通路了一次，那麼它就被認為是熱點資料，不會被淘汰，而有些key将來是很有可能被通路到的則被淘汰了。如果使用LFU算法則不會出現這種情況，因為使用一次并不會使一個key成為熱點資料。

LFU一共有兩種政策：

• volatile-lfu：在設定了過期時間的key中使用LFU算法淘汰key
• allkeys-lfu：在所有的key中使用LFU算法淘汰資料

問題