缓存淘汰算法与 python 中 lru_cache 装饰器的实现

最新推荐文章于 2024-04-02 21:31:18 发布
最新推荐文章于 2024-04-02 21:31:18 发布
阅读量2.3k 收藏 32
点赞数 9
分类专栏： 技术分享 文章标签： python 缓存 缓存淘汰 lru 架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DILIGENT203/article/details/103251197
版权

缓存淘汰算法与 python 中 lru_cache 装饰器的实现

1. 引言

此前的文章中，我们介绍过常见两种缓存架构 – 穿透型缓存与旁路型缓存。
常见缓存架构 – 穿透型缓存与旁路型缓存

穿透型缓存与旁路型缓存架构的主要区别在于当缓存中不存在被访问数据时的处理方式。
但是，缓存的容量是有限的，随着时间的发展，无论是使用穿透型缓存还是旁路型缓存的架构，最终都会面临缓存被占满的情况，那么此时，为了缓存数据的实时性，我们需要淘汰一些旧的、访问率低的数据来增加空闲空间以便缓存的继续使用。
应该如何选择被淘汰的数据呢？这就是缓存淘汰算法的目标。

2. 缓存淘汰算法

最常见的缓存淘汰算法有以下这些：

2.1. 先进先出 – FIFO

FIFO 即 First In First Out 的缩写，这可以说是实现起来最简单的一种算法了。
缓存维护一个队列，总是在队首插入数据，当缓存区满时，则删除队尾数据。

# 此处有图片 1

这个算法的优点就在于实现简单，但缺点也是显而易见的：

  1. 顺序写入与读出往往不符合我们的业务场景，虽然我们可以通过叠加其他数据结构让队列可以支持随机访问来规避这个缺点
  2. 先写入的数据并不一定比后写入的数据重要性低，这是该算法的主要问题

2.2. 最不经常使用算法 – LFU

LFU 是 least frequently used 的缩写。
算法思想是淘汰那些被访问次数最少的数据。
其实现方式也非常简单，只需要维护一个队列，存储数据与被访问次数的对应关系。
每次数据被访问时，增加其对应的访问次数值，并将该节点在链表中向队首移动，直到整个队列从对少到队尾仍然保持按访问次数递减存储。
当需要执行淘汰算法时，只要淘汰队尾的部分数据即可。

# 此处有图片 2

这个算法相比于先进先出算法，他兼顾了数据的访问次数，从而避免热数据先于冷数据被淘汰。
但是，这个算法仍然存在一定的问题，那就是一旦某个数据在短时间被大量访问，此后即便很长时间没有任何访问，该数据仍然凭借其巨大的访问次数数值而不被淘汰。

2.3. 最近最少使用算法 – LRU

LRU 是 Least Recently Used 的缩写。
这是目前实践中最为广泛使用的一种缓存淘汰算法，他的算法思想与 LFU 非常相似，但他去除了访问次数数值，在队列中采用访问则上升的策略，从而规避了上面提到的访问次数数值过大造成的影响。
由于该算法的广泛使用性，我们下文将以 python 中十分常用的方法执行参数与结果的缓存 – functools.lru_cache，来详细介绍一下该算法。

# 此处有图片 3

2.4. 最近最常使用算法 – MRU

与 LRU 相对，MRU 是 Most recently used 的缩写。
这个算法与 LRU 恰好相反，MRU 算法优先移除最近被使用过的数据，它用来处理越久没有被使用的数据越容易被访问到的情况。

3. LRU 的实现 – python 标准库 functools.lru_cache 装饰器的实现

python 标准库中的 functools.lru_cache 装饰器实现了一个 LRU 算法的缓存，用来缓存方法所有参数与返回值的对应关系，用来提升一个方法频繁用相同参数调用场景下的性能。
关于 python 的闭包与装饰器，参考此前的文章：
python 中的闭包
python 中的装饰器及其原理

3.1. 简化后源码

下面是抽取简化后的 python 标准库 functools.lru_cache 源码：

def make_key(args, kwds):
    """
    通过方法参数获取缓存的 key
    :param args: 方法原始参数
    :param kwds: 方法键值对参数
    :return: 计算后 key 的 hash 值
    """
    key = args
    if kwds:
        key += object()
        for item in kwds.items():
            key += item
    elif len(key) == 1 and type(key[0]) in {int, str, frozenset, type(None)}:
        return key[0]
    return hash(key)


def lru_cache(maxsize=128):
    def decorating_function(user_function):
        PREV, NEXT, KEY, RESULT = 0, 1, 2, 3

        cache = {}                          # 缓存结构，存储 key 与缓存数据的映射
        hits = misses = 0                   # 缓存命中、丢失统计
        full = False                        # 缓冲区是否已满标记
        cache_len = cache.__len__           # 缓冲区大小
        root = []
        root[:] = [root, root, None, None]  # 队列头结点为空

        def lru_cache_wrapper(*args, **kwds):
            nonlocal root, hits, misses, full
            key = make_key(args, kwds)
            with RLock():  # 线程安全锁
                link = cache.get(key)

                """ 缓存命中，移动命中节点，直接返回预设结果 """
                if link is not None:
                    """ 从链表中移除命中节点 """
                    link_prev, link_next, _key, result = link
                    link_prev[NEXT] = link_next
                    link_next[PREV] = link_prev

                    """ 将命中节点移动到队尾 """
                    last = root[PREV]
                    last[NEXT] = root[PREV] = link
                    link[PREV] = last
                    link[NEXT] = root
                    hits += 1
                    return result

            """ 缓存未命中，调用方法获取返回，创建节点，淘汰算法 """
            result = user_function(*args, **kwds)
            with RLock():
                if key in cache:
                    pass
                elif full:
                    """ 缓冲区已满，淘汰队首元素，删除缓冲区对应元素 """
                    oldroot = root
                    oldroot[KEY] = key
                    oldroot[RESULT] = result
                    root = oldroot[NEXT]
                    oldkey = root[KEY]
                    root[KEY] = root[RESULT] = None
                    del cache[oldkey]
                    cache[key] = oldroot
                else:
                    """ 缓冲区未满，直接创建节点，插入数据 """
                    last = root[PREV]
                    link = [last, root, key, result]
                    last[NEXT] = root[PREV] = cache[key] = link
                    full = (cache_len() >= maxsize)
                misses += 1
            return result
        return lru_cache_wrapper

    return decorating_function

3.2. 算法流程

上述代码的实现逻辑非常清晰，实现方式也非常巧妙。
他利用字典实现了一个缓冲区，同时创建了一个环形双向链表，而链表中每个节点都是一个 list，list 中的四个元素分别代表前驱的引用、后继引用、key、函数返回值。
通过缓冲区与环形双向链表的同步操作完成 LRU 算法的实现。

  1. 【初始状态】 初始状态下，cache 字典为空，环形双向链表中只有 key、result 均为 None 的 root 节点
  2. 【缓存命中】 当插入元素命中缓存，则在链表中移除该节点，并将该节点插入 root 之前，实现最近使用数据在链表中位置的提升
  3. 【缓存未命中且队列未满】 当插入元素未命中缓存，则创建该元素的节点，并直接在环形双线链表的 root 之前插入节点，cache[key] 赋值为插入节点
  4. 【缓存未命中且队列已满】 此时需要触发 LRU 缓存淘汰算法，此时将 root 的 key 与 result 分别赋值为待插入节点对应的值，向后移动 root，将 root 的 key、result 分别赋值为 None，从而实现 root 后相邻节点的清除，cache[key] 赋值为插入节点，删除 cache 中被移除节点

下图展示了缓冲命中与缓存淘汰两种场景下的算法执行过程：

# 此处有图片 4

4. 利用 lru_cache 优化方法执行

此前我们曾经提到，由于 python 没有尾递归优化，递归执行算法效率是很低的。
在此前的文章中，针对这一情况，我们自行实现了简易的尾递归优化。
经典动态规划问题 – 青蛙上台阶与 python 的递归优化

4.1. 斐波那契数列的递归生成

让我们加上此前文章中的 clock 装饰器，再次看看递归生成斐波那契数列的程序。

def clock(func):
    @functools.wraps(func)
    def clocked(*args, **kwargs):
        t0 = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - t0
        name = func.__name__
        arg_lst = []
        if args:
            arg_lst.append(', '.join(repr(arg) for arg in args))
        if kwargs:
            pairs = ['%s=%r' % (k, w) for k, w in sorted(kwargs.items())]
            arg_lst.append(', '.join(pairs))
        arg_str = ', '.join(arg_lst)
        print('[%0.8fs] %s(%s) -> %r ' % (elapsed, name, arg_str, result))
        return result

    return clocked


@lru_cache()
@clock
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 2) + fibonacci(n - 1)


if __name__ == '__main__':
    print(fibonacci(6))

执行程序，打印出了：

[0.00000000s] fibonacci(0) -> 0
[0.00000000s] fibonacci(1) -> 1
[0.00000000s] fibonacci(2) -> 1
[0.00000000s] fibonacci(1) -> 1
[0.00000000s] fibonacci(0) -> 0
[0.00000000s] fibonacci(1) -> 1
[0.00000000s] fibonacci(2) -> 1
[0.00000000s] fibonacci(3) -> 2
[0.00050116s] fibonacci(4) -> 3
[0.00000000s] fibonacci(1) -> 1
[0.00000000s] fibonacci(0) -> 0
[0.00000000s] fibonacci(1) -> 1
[0.00000000s] fibonacci(2) -> 1
[0.00000000s] fibonacci(3) -> 2
[0.00000000s] fibonacci(0) -> 0
[0.00000000s] fibonacci(1) -> 1
[0.00000000s] fibonacci(2) -> 1
[0.00000000s] fibonacci(1) -> 1
[0.00000000s] fibonacci(0) -> 0
[0.00000000s] fibonacci(1) -> 1
[0.00000000s] fibonacci(2) -> 1
[0.00000000s] fibonacci(3) -> 2
[0.00000000s] fibonacci(4) -> 3
[0.00000000s] fibonacci(5) -> 5
[0.00050116s] fibonacci(6) -> 8
8

可以看到，有很多重复参数的调用在消耗着程序性能，随着数列规模的增长，重复调用的次数将成倍增长。
一个有效的优化条件就是将这些重复调用的结果缓存起来，再次调用时直接返回即可，这正是 lru_cache 的用途。

4.2. 使用 lru_cache 优化斐波那契数列的生成

import functools
import time
from _thread import RLock


def make_key(args, kwds):
    """
    通过方法参数获取缓存的 key
    :param args: 方法原始参数
    :param kwds: 方法键值对参数
    :return: 计算后 key 的 hash 值
    """
    key = args
    if kwds:
        key += object()
        for item in kwds.items():
            key += item
    elif len(key) == 1 and type(key[0]) in {int, str, frozenset, type(None)}:
        return key[0]
    return hash(key)


def lru_cache(maxsize=128):
    def decorating_function(user_function):
        PREV, NEXT, KEY, RESULT = 0, 1, 2, 3

        cache = {}                          # 缓存结构，存储 key 与缓存数据的映射
        hits = misses = 0                   # 缓存命中、丢失统计
        full = False                        # 缓冲区是否已满标记
        cache_len = cache.__len__           # 缓冲区大小
        root = []
        root[:] = [root, root, None, None]  # 队列头结点为空

        def lru_cache_wrapper(*args, **kwds):
            nonlocal root, hits, misses, full
            key = make_key(args, kwds)
            with RLock():  # 线程安全锁
                link = cache.get(key)

                """ 缓存命中，移动命中节点，直接返回预设结果 """
                if link is not None:
                    """ 从链表中移除命中节点 """
                    link_prev, link_next, _key, result = link
                    link_prev[NEXT] = link_next
                    link_next[PREV] = link_prev

                    """ 将命中节点移动到队尾 """
                    last = root[PREV]
                    last[NEXT] = root[PREV] = link
                    link[PREV] = last
                    link[NEXT] = root
                    hits += 1
                    return result

            """ 缓存未命中，调用方法获取返回，创建节点，淘汰算法 """
            result = user_function(*args, **kwds)
            with RLock():
                if key in cache:
                    pass
                elif full:
                    """ 缓冲区已满，淘汰队首元素，删除缓冲区对应元素 """
                    oldroot = root
                    oldroot[KEY] = key
                    oldroot[RESULT] = result
                    root = oldroot[NEXT]
                    oldkey = root[KEY]
                    root[KEY] = root[RESULT] = None
                    del cache[oldkey]
                    cache[key] = oldroot
                else:
                    """ 缓冲区未满，直接创建节点，插入数据 """
                    last = root[PREV]
                    link = [last, root, key, result]
                    last[NEXT] = root[PREV] = cache[key] = link
                    full = (cache_len() >= maxsize)
                misses += 1
            return result
        return lru_cache_wrapper

    return decorating_function


def clock(func):
    @functools.wraps(func)
    def clocked(*args, **kwargs):
        t0 = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - t0
        name = func.__name__
        arg_lst = []
        if args:
            arg_lst.append(', '.join(repr(arg) for arg in args))
        if kwargs:
            pairs = ['%s=%r' % (k, w) for k, w in sorted(kwargs.items())]
            arg_lst.append(', '.join(pairs))
        arg_str = ', '.join(arg_lst)
        print('[%0.8fs] %s(%s) -> %r ' % (elapsed, name, arg_str, result))
        return result

    return clocked


@lru_cache()
@clock
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 2) + fibonacci(n - 1)


if __name__ == '__main__':
    print(fibonacci(6))

打印出了：

[0.00000000s] fibonacci(0) -> 0
[0.00000000s] fibonacci(1) -> 1
[0.00000000s] fibonacci(2) -> 1
[0.00000000s] fibonacci(3) -> 2
[0.00000000s] fibonacci(4) -> 3
[0.00000000s] fibonacci(5) -> 5
[0.00000000s] fibonacci(6) -> 8
8

我们看到，方法从原来的 25 次递归调用变成了只有 7 次递归调用，执行时间上的优化效果也是相当明显。

5. 微信公众号

欢迎关注微信公众号，以技术为主，涉及历史、人文等多领域的学习与感悟，每周三到七篇推文，全部原创，只有干货没有鸡汤。

# 此处有图片 5

DILIGENT203
关注
  • 9
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
python @lru_cache()
yake1965
08-18 1728
python @lru_cache()
Python缓存lru_cache的介绍和讲解
热门推荐
曲鸟
11-23 2万+
我们经常谈论的缓存一词，更多的类似于将硬盘中的数据存放到内存中以至于提高读取速度，比如常说的redis，就经常用来做数据的缓存。 Python的缓存（lru_cache）是一种装饰在被执行的函数上，将其执行的结果缓存起来，当下次请求的时候，如果请求该函数的传参未变则直接返回缓存起来的结果而不再执行函数的一种缓存装饰器。 那它和redis的区别在哪？有什么优势？怎么使用？ 下面为你讲解
@lru_cache 内置 LRU 缓存
thinker
10-17 2087
Python 内置模块 functools 的一个高阶函数 @lru_cache 是一个为函数提供缓存功能的装饰器，缓存 maxsize 组传入参数，在下次以相同参数调用时直接返回上一次的结果。用以节约高开销或 I/O 函数的调用时间。
如何使用Python内置缓存装饰器: @lru_cache，@cache 与 @cached_property
Python技术探索
06-28 9369
Python 的内置库 functools 模块附带了@lru_cache，@cache, @cached_property 装饰器，可用于在代码中，对函数运算结果，类成员方法运算结果，进行缓存。上例中，每次运行函数时，lru_cache都会检查输入，如果之前运行过，则从缓存中返回结果 ，如果没有，则运行函数，并缓存结果。本文介绍了3种缓存工具的使用步骤，最后总结了对应的适用场景建议。
在 Python 中使用 LRU 缓存策略
allway2的博客
06-05 1132
由圣地亚哥Valdarrama2020 年 11 月 4 日中间的Python 标记为已完成 鸣叫分享电子邮件 目录 缓存及其用途 使用 Python 字典实现缓存 缓存策略 深入研究最近最少使用 (LRU) 缓存策略 窥视 LRU 缓存的幕后 在 Python 中使用 @lru_cache 实现 LRU 缓存 玩楼梯 为你的代码计时 使用记忆来改进解决方案 解包@lru_cache 的功能 添加缓存过期 基于时间和空间驱逐...
工程师必须了解的LRU缓存淘汰算法以及python实现过程
12-16
大家好，欢迎大家来到算法数据结构专题，今天我们和大家聊一个非常常用的算法，叫做LRU。 LRU的英文全称是Least Recently Used，也即最不经常使用。我们看着好像挺迷糊的，其实这个含义要结合缓存一起使用。对于工程...
Python实现LRU算法的2种方法
09-21
在Python中，我们可以使用不同的方式来实现LRU算法，主要介绍两种方法：使用`collections.OrderedDict`和使用`dict`与`list`的组合。 ### 方法一：使用`collections.OrderedDict` `collections.OrderedDict` 是...
Python实现的一个简单LRU cache
12-25
LRU (Least Recently Used) 缓存是一种...这个实现遵循了LRU策略，确保了最近访问的元素在缓存中保留，而最不常访问的元素被优先淘汰。对于大型数据集，这样的设计能够有效减少数据库查询次数，提高程序的运行效率。
lrucacheleetcode-LRU_Cache:LRU_Cache
06-29
在计算机科学中，特别是在数据库、操作系统和编程语言的实现中，LRU缓存机制广泛应用于缓存淘汰算法。当缓存满时，最近最少使用的数据会被淘汰，以腾出空间给新的或者更频繁访问的数据。 LeetCode 是一个知名的在线...
PyPI 官网下载 | backports.functools_lru_cache-1.3.tar.gz
01-26
《PyPI上的backports.functools_lru_cache-1.3.tar.gz：...通过学习其源码，我们可以深入了解Python装饰器的实现机制，以及LRU缓存策略在实际编程中的应用。对于提升代码质量和性能，这是一份非常有价值的参考资料。
Python缓存技术，装x新高度。
dianyin7770的博客
09-02 638
一段非常简单代码 普通调用方式 def console1(a, b): print("进入函数") return (a, b) print(console1(3, 'a')) print(console1(2, 'b')) print(console1(3.0, 'a')) 很简单的一段代码，传入两个参数。然后打印输出。 输出结果 进入函数 (3, 'a') 进入函数 ...
Python内置装饰器：@lru_cache 和 @cache【leetcode808. 分汤】
最新发布
longforone的博客
04-02 1466
和 是Python标准库中提供的两种缓存装饰器，它们可以将函数计算的结果缓存起来，下次调用的时候直接返回结果 装饰器位于 模块中，它使用最近最少使用（LRU）算法来缓存函数调用的结果。当你使用这个装饰器时，函数的调用结果将根据参数被缓存起来。如果再次出现相同的参数，函数将直接从缓存中获取结果，而不是重新执行，从而提高效率。 在上面的例子中， 是一个计算密集型的函数，我们使用 来缓存它的结果。 参数指定了缓存中可以存储的最大调用次数。如果没有设置 或者设置为 ，则缓存不会自动清除，但可能会消耗大量内存
leetcode146. LRU 缓存【python3哈希表+双向链表】利用OrderedDict以及自实现双向链表
闯入网络安全的数据分析小白
01-11 482
leetcode 笔记
Python 的 @lru_cache() 装饰器
咖啡花园
11-18 200
装饰器是通过空间换取时间的方式来提高程序的性能，所以。通过下面的例子可以很好的理解。在 Python 标准库的。
Python深度解析：functools.lru_cache装饰器
love_521_的博客
12-28 722
functools.lru_cache是Python标准库中的一个装饰器，用于添加缓存功能。LRU代表最近最少使用，这意味着该缓存会保留最近使用的数据，而丢弃最长时间未使用的数据。# ...
【Python】Python实现LRU_Cache
sinat_21791203的专栏
03-15 1632
题目 1.给出斐波那契数列的递归解法，找一种方法优化该函数 2.如果我们的空间有限怎么办？也就是说当内存有限的时候，我们需要有一种策略来解决缓存已满的问题。 常规优化法就是给他加上一个数组来存储已经计算过的值，避免重复计算 Pythonic的写法是给他加上一个装饰器， 装饰器的思路：用一个字典来缓存已经计算过的内容，如果传过来的参数在我们的保存结果里面就可以直接返回，如果不在...
python装饰器原理 | 常用装饰器使用(@cache, @lru_cache)
weixin_43646592的博客
02-22 4507
python装饰器原理 | 常用装饰器使用(@cache, @lru_cache)
Python 缓存机制与 functools.lru_cache
ronon77的专栏
06-08 1万+
      缓存是一种将定量数据加以保存以备迎合后续请求的处理方式，旨在加快数据的检索速度。我们先通过一个简单的例子来了解缓存机制的概念： # -*- coding: utf-8 -*- import datetime import random class MyCache: """""" def __init__(self): """C...
如何实现LRU缓存淘汰算法
06-07
实现LRU缓存淘汰算法的一种常用方法是使用哈希表和双向链表结合实现。具体实现步骤如下： 1. 使用一个哈希表来存储缓存中的键值对，其中键为缓存的键，值为该键对应的节点在双向链表中的指针。 2. 使用一个双向...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值