> 作者：沈熠輝
> 來源：[恆生LIGHT雲社群](https://developer.hs.net/thread/1081)
# Redis使用場景

現在公司的業務越來越複雜，我們需要抽出一個使用者系統，向各個業務系統提供使用者的基本資訊。

![業務001.jpg](https://developer.hs.net/storage/attachments/2021/06/11/PKjpcmv2tIUxJRYtfM4r8PBskVsgYgDQczXp3vOx_thumb.jpg "1413")

業務方對使用者資訊的查詢頻率很高，一定要注意效能問題哦。

使用者資訊當然是存放在資料庫裡，但是由於我們對使用者系統的效能要求比較高，顯然不能在每一次請求時都去查詢資料庫。

所以，在記憶體中建立了一個雜湊表作為快取，每當查詢一個使用者時會先在雜湊表中進行查詢，以此來提高訪問的效能。

![業務002.jpg](https://developer.hs.net/storage/attachments/2021/06/11/imzV3XKHLj7XdcujWosg2cRk9zVjdYCVvMc1Dijx_thumb.jpg "1414")

# 很快發現了個問題

線上伺服器當機了！

糟了，是記憶體溢位了，使用者數量越來越多，當初設計的雜湊表把記憶體給撐爆了，趕緊重啟吧！

可是以後該怎麼辦呢？我們能不能給伺服器的硬體升級，或者加幾臺伺服器呀？

那我能不能在記憶體快耗盡的時候，隨機刪掉一半使用者快取呢？

唉，這樣也不妥，如果刪掉的使用者資訊，正好是被高頻查詢的使用者，會影響系統效能的。

# 你聽說過LRU演算法嗎？

LRU全稱Least Recently Used，也就是最近最少使用的意思，是一種記憶體管理演算法，該演算法最早應用於Linux作業系統。

這個演算法基於一種假設：長期不被使用的資料，在未來被用到的機率也不大。因此，當資料所佔記憶體達到一定閾值時，我們要移除最近最少被使用的資料。

原來如此，這個演算法正好對我的使用者系統有幫助！可以在記憶體不夠時，從雜湊表中移除一部分很少被訪問的使用者。

可是，我怎麼知道雜湊表中哪些Key-Value最近被訪問過，哪些沒被訪問過？總不能給每一個Value加上時間戳，然後遍歷整個雜湊表吧？

這就能展現LRU演算法的精妙所在了。在LRU演算法中，使用了一種有趣的資料結構，這種資料結構叫作雜湊連結串列。

什麼是雜湊連結串列呢？

我們都知道，雜湊表是由若干個Key-Value組成的。在“邏輯”上，這些Key-Value是無所謂排列順序的，誰先誰後都一樣。

![雜湊連結串列01.jpg](https://developer.hs.net/storage/attachments/2021/06/11/CYmBSb2m7iS89Xb1jdH3u15xpZ3UwUagOecDlGtb_thumb.jpg "1415")

在雜湊連結串列中，這些Key-Value不再是彼此無關的了，而是被一個鏈條串了起來。每一個Key-Value都具有它的前驅Key-Value、後繼Key-Value，就像雙向連結串列中的節點一樣。

![使用者資訊02.jpg](https://developer.hs.net/storage/attachments/2021/06/11/9rwbFVJhKRqO0jxKdy0N8kpGQIFNAi23vTajxk1W_thumb.jpg "1416")

這樣一來，原本無序的雜湊表就擁有了固定的排列順序。

可是，這雜湊連結串列和LRU演算法有什麼關係呢？

依靠雜湊連結串列的有序性，我們可以把Key-Value按照最後的使用時間進行排序。

讓我們以使用者資訊的需求為例，來演示一下LRU演算法的基本思路。

1.假設使用雜湊連結串列來快取使用者資訊，目前快取了4個使用者，這4個使用者是按照被訪問的時間順序依次從連結串列右端插入的。

![使用者資訊03.jpg](https://developer.hs.net/storage/attachments/2021/06/11/Oz1S1ddNumYMLrKH5sn59vClDuuDjAKb4q7MO3OX_thumb.jpg "1417")

![使用者資訊04.jpg](https://developer.hs.net/storage/attachments/2021/06/11/kmi0GCIe0sQsTYRR6XHwJikmEURlp1bxryyJGQMM_thumb.jpg "1419")

4.接下來，如果業務方請求修改使用者4的資訊。同樣的道理，我們會把使用者4從原來 的位置移動到連結串列的最右側，並把使用者資訊的值更新。這時，連結串列的最右端是最新被訪問的使用者4，最左端仍然是最近最少被訪問的使用者1。

![使用者資訊05.jpg](https://developer.hs.net/storage/attachments/2021/06/11/zYTbbImqfHZ06Eoy2Z25m7NWxSgMRKpa2PQ96xMu_thumb.jpg "1421")

![使用者資訊06.jpg](https://developer.hs.net/storage/attachments/2021/06/11/5adzQSZaystcVJBHXgT9BZ2NZVYuyQnFTGjQv7e6_thumb.jpg "1420")

5.後來業務方又要訪問使用者6，使用者6在快取裡沒有，需要插入雜湊連結串列中。假設這時快取容量已經達到上限，必須先刪除最近最少被訪問的資料，那麼位於雜湊連結串列最左端的使用者1就會被刪除，然後再把使用者6插入最右端的位置。

![使用者資訊07.jpg](https://developer.hs.net/storage/attachments/2021/06/11/yTWoFK9h3XXCVIxnfKdrv5tsYKt7cfQqWvRkAmWv_thumb.jpg "1422")![使用者資訊08.jpg](https://developer.hs.net/storage/attachments/2021/06/11/sZKwatO3L5FRUDDtuwSwWCIO0ySt68bHS1hxR3N8_thumb.jpg "1423")

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

明白了，這真是個巧妙的演算法！那麼LRU演算法怎麼用程式碼來實現呢？

# 簡單實現

```
class LRUCache:
    def __init__(self,limit):
        self.limit=limit
        self.hash={}
        self.head=None
        self.end=None
    def get(self,key):
        node=self.hash.get(key)
        if node is None:
            return None
        self.refresh_node(node)
        return node.value
    def put(self,key,value):
        node=self.hash.get(key)
        if node is None:
            #如果key不存在，插入key-value
            if len(self.hash) >= self.limit:
                old_key=self.remove_node(self.head)
                self.hash.pop(old_key)
            node=Node(key,value)
            self.add_node(node)
            self.hash[key]=node
        else:
            #如果key存在，重新整理key-value
            node.value=value
            self.refresh_node(node)
    def remove(self,key):
        node=self.hash.get(key)
        self.remove_node(node)
        self.hash.remove(key)
    def refresh_node(self,node):
        #如果訪問的是尾節點,無需移動節點
        if node==self.end:
           return
        #移除節點
        self.remove_node(node)
        #重新插入節點
        self.add_node(node)
    def remove_node(self,node):
        if node==self.head and node==self.end:
            #移除唯一的節點
            self.head=None
            self.end=None
        elif node==self.end:
            #移除節點
            self.end=self.end.pre
            self.end.next=None
        elif node==self.head:
            #移除頭節點
            self.head=self.head.next
            self.head.pre=None
        else:
            #移除中間節點
            node.pre.next=node.next
            node.next.pre=node.pre
        return node.key
    def add_node(self,node):
        if self.end is not None:
            self.end.next=node
            node.pre=self.end
            node.next=None
        self.end=node
        if self.head is None:
           self.head=node

class Node:
    def __init__(self,key,value):
        self.key=key
        self.value=value
        self.pre=None
        self.next=None

lruCache=LRUCache(5)

lruCache.put("001","使用者1資訊")
lruCache.put("002","使用者2資訊")
lruCache.put("003","使用者3資訊")
lruCache.put("004","使用者4資訊")
lruCache.put("005","使用者5資訊")

print(lruCache.get("001"))
print(lruCache.get("002"))
print(lruCache.get("003"))
print(lruCache.get("004"))
print(lruCache.get("005"))
lruCache.refresh_node(lruCache.hash.get("002"))
print(lruCache.hash.get("001").next.value)
print(lruCache.hash.get("003").pre.value)

print(lruCache.hash.get("002").value)

```

redis的記憶體滿了之後，redis如何回收記憶體嗎

相關文章