LRU缓存：聪明存储，快速淘汰！

你一身傲骨怎能输

于 2025-05-11 01:03:56 发布

阅读量450

点赞数 21

分类专栏：数据结构与算法文章标签：缓存

本文链接：https://blog.csdn.net/qq_33060405/article/details/147863523

版权

数据结构与算法专栏收录该内容

118 篇文章

订阅专栏

摘要

LRU缓存是一种高效的数据存储方法，其核心思想是“最近最少使用”，即优先淘汰最久未使用的数据。通过生活中的比喻，如书包里的课本和冰箱里的饮料，可以形象地理解LRU缓存的工作原理：当空间不足时，最久未使用的物品会被移除，为新物品腾出空间。LRU缓存通常通过哈希表和双向链表实现，哈希表用于快速查找，双向链表用于记录使用顺序。这种结构使得查找、插入和删除操作都能在O(1)时间内完成。LRU缓存广泛应用于浏览器缓存、操作系统内存管理和数据库缓存等场景，因其自动淘汰机制和高效性能而备受青睐。

一、LRU缓存是什么？一句话解释

LRU缓存是一种“只记得最近用过的东西，最久没用的就先扔掉”的聪明存储方法。

二、生活中的形象比喻

1. 书包里的课本

想象你有一个小书包，只能装下4本书。老师每天可能会让你用不同的课本。

你每次用书时，如果书包里有，就直接拿出来用。
如果没有，就得去教室书架上拿一本放进书包。
但书包满了怎么办？你会把最久没用过的那本书拿出来放回书架，把新书放进去。

这就是LRU缓存的思想！

2. 冰箱里的饮料

你家冰箱只能放4瓶饮料。每次你想喝饮料时：

如果冰箱里有你想喝的，直接拿出来喝（命中）。
如果没有，就去超市买一瓶放进冰箱。
冰箱满了？你会把最久没喝的那瓶扔掉，腾出空间给新买的。

三、LRU缓存的结构

要实现LRU缓存，通常用哈希表+双向链表的组合：

哈希表：快速查找某个东西在不在缓存里（O(1)时间）。
双向链表：记录每个东西的“新鲜度”顺序，最新用的放前面，最久没用的放后面。

四、LRU缓存的工作流程

访问缓存（查找/使用）
- 如果东西在缓存里（比如书包里有这本书），就把它挪到最前面（表示刚用过）。
- 如果不在缓存里（书包里没有），就：
  - 从外面拿进来（比如去书架拿书）。
  - 如果书包满了，把最后面的那本（最久没用的）拿出去。
  - 新书放到最前面。
插入新内容
- 先查查有没有，有就更新顺序。
- 没有就加进来，满了就先扔掉最久没用的。

五、动画想象

想象你的书包里排着4本书，最前面的是刚用过的，最后面的是最久没用的。

每次用一本书，就把它挪到最前面。
新书进来，满了就把最后一本扔掉。

六、LRU缓存的优点

查找快：哈希表O(1)查找。
更新快：双向链表O(1)插入和删除。
自动淘汰：最久不用的自动被踢出去。

七、LRU缓存的应用场景

浏览器缓存：只保存最近访问过的网页，老的自动清理。
操作系统内存管理：只保留最近用过的程序数据。
数据库缓存：只缓存最近查询的数据，节省内存。

八、口诀总结

新用的放前头，老用的往后溜，满了就扔最后，LRU缓存真灵巧！

九、简单代码（Python伪代码）

class LRUCache:
    def __init__(self, capacity):
        self.cache = {}  # 哈希表
        self.order = DoublyLinkedList()  # 双向链表
        self.capacity = capacity

    def get(self, key):
        if key in self.cache:
            # 把用过的节点移到最前面
            self.order.move_to_front(self.cache[key])
            return self.cache[key].value
        else:
            return -1

    def put(self, key, value):
        if key in self.cache:
            # 更新值并移到最前面
            self.cache[key].value = value
            self.order.move_to_front(self.cache[key])
        else:
            if len(self.cache) == self.capacity:
                # 淘汰最后一个
                old = self.order.remove_last()
                del self.cache[old.key]
            # 新节点加到最前面
            node = Node(key, value)
            self.order.add_to_front(node)
            self.cache[key] = node

十、再用一句话总结

LRU缓存就像一个只能装有限东西的书包，最久没用的先扔掉，最新用的永远在最前面，既聪明又高效！

我们继续用生动形象的方式，深入讲解 LRU 缓存的更多细节、原理、应用和与其他缓存策略的对比！

十一、LRU缓存的“淘汰”过程再举例

1. 书包换书动画

假设你的书包容量是3本书，顺序从前到后分别是：

前面：数学（刚用过）
中间：语文
后面：英语（最久没用）

现在你要用“物理”课本：

书包满了，得扔掉最久没用的“英语”。
把“物理”放到最前面，书包变成：
- 物理（刚用过）
- 数学
- 语文

2. 冰箱饮料动画

冰箱里有：可乐、雪碧、橙汁（从新到旧）。

你想喝“牛奶”：

冰箱满了，扔掉最久没喝的“橙汁”。
把“牛奶”放到最前面，冰箱变成：
- 牛奶、可乐、雪碧

十二、LRU缓存的底层结构再形象解释

1. 哈希表+双向链表

哈希表：像是每本书的“定位器”，能一秒钟找到书在书包的哪个位置。
双向链表：像是书包里的“队列”，前面是最新用的，后面是最久没用的。

为什么用双向链表？
因为你要把某本书挪到最前面，或者把最后一本书扔掉，双向链表都能O(1)完成。

十三、LRU缓存的常见面试题

如何实现LRU缓存？
- 哈希表+双向链表，查找、插入、删除都是O(1)。
为什么不用单链表？
- 单链表删除中间节点需要遍历，效率低。
为什么不用数组？
- 数组插入和删除需要移动元素，效率低。

十四、LRU与其他缓存策略的对比

策略	淘汰规则	适用场景	优缺点
LRU	最久未使用的先淘汰	访问有“时间局部性”	实现简单，效果好
LFU	使用最少的先淘汰	访问有“频率局部性”	适合热点数据，复杂度高
FIFO	最早进入的先淘汰	简单缓存	实现最简单，命中率低
Random	随机淘汰	特殊场景	实现简单，效果不稳定

形象比喻：

LRU：书包里最久没用的书先扔。
LFU：书包里最少用的书先扔。
FIFO：最早放进书包的书先扔。
Random：随便扔一本。

十五、LRU缓存的应用场景再举例

浏览器历史记录
- 只保留最近访问的网页，老的自动清理。
CPU缓存
- 只保留最近用过的数据块，提升访问速度。
数据库查询缓存
- 只缓存最近查询的数据，节省内存。

十六、LRU缓存的可视化学习资源

十七、LRU缓存的简化Python实现

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

class LRUCache:
    def __init__(self, capacity):
        self.cache = {}
        self.capacity = capacity
        self.head = Node(0, 0)  # 虚拟头
        self.tail = Node(0, 0)  # 虚拟尾
        self.head.next = self.tail
        self.tail.prev = self.head

    def _remove(self, node):
        prev, nxt = node.prev, node.next
        prev.next, nxt.prev = nxt, prev

    def _add(self, node):
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node

    def get(self, key):
        if key in self.cache:
            node = self.cache[key]
            self._remove(node)
            self._add(node)
            return node.value
        return -1

    def put(self, key, value):
        if key in self.cache:
            self._remove(self.cache[key])
        node = Node(key, value)
        self._add(node)
        self.cache[key] = node
        if len(self.cache) > self.capacity:
            # 删除最久未用的
            lru = self.tail.prev
            self._remove(lru)
            del self.cache[lru.key]