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

最新推荐文章于 2024-10-25 12:33:35 发布
最新推荐文章于 2024-10-25 12:33:35 发布
阅读量2.4k 收藏 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

python函数通过lru_cache缓存加速
XiaoPANGXia的专栏
06-11 1954
通过lru_cache缓存加速 不加缓存 %%time def fib(n): return(1 if n in [1, 2] else fib(n-1)+fib(n-2)) print(fib(35)) 9227465 Wall time: 2.11 s 加lru_cache缓存，递归快的一笔 %%time from functools import lru_cache #...
python实现LRU缓存淘汰
you are sherlocked by me!
06-22 584
LRU  Least Recent used 最近最少使用算法，主要用于缓存淘汰. 主要目的就是把最近最少使用的数据移除内存，以加载其他数据 原理:  有新数据(意味着数据之前没有被缓存过)时,加入到列表头 缓存达到最大容量时, 需要淘汰数据多出来的数据,此时淘汰列表尾部的数据 当缓存中有数据被命中, 则将数据移动到列表头部(相当于新加入缓存)  从前面的文章中我们可以知道，缓存简化下来就两个功能，一个是往里装数据（缓存数据），一个是往外吐数据（命中缓存），所以我们的缓存对外只需要put和get两.
使用 Python 的 lru cache 为接口实现高效缓存
最新发布
享受、分享
10-25 211
lru_cache 是 Python 标准库中 functools 模块提供的装饰器，用于缓存函数的返回结果。LRU 代表 “Least Recently Used”（最近最少使用），这意味着这个缓存机制会自动删除最久未使用的缓存。有时我们需要在特定条件下清理缓存，例如每天更新一次。CACHE_EXPIRATION = 24 * 60 * 60 # 24小时last_cache_update = [0] # 使用列表作为可变容器# 进行一些昂贵的计算。
python 缓存淘汰
weixin_42062230的博客
08-15 149
class LRUcache: def __init__(self, size=5): self.cache = {} self.elems = [] self.size = size def get_data(self, elem): if elem in self.cache: self...
python @lru_cache()
yake1965
08-18 1783
python @lru_cache()
Python 内置缓存之@lru_cache
Seven_Cloud的博客
09-08 920
@lru_cache：通过缓存加速程序
工程师必须了解的LRU缓存淘汰算法以及python实现过程
12-16
大家好，欢迎大家来到算法数据结构专题，今天我们和大家聊一个非常常用的算法，叫做LRU。 LRU的英文全称是Least Recently Used，也即最不经常使用。我们看着好像挺迷糊的，其实这个含义要结合缓存一起使用。对于工程而言，缓存是非常非常重要的机制，尤其是在当下的互联网应用环境当中，起到的作用非常重要。为了便于大家更好地理解，我们从缓存的机制开始说起。 缓存 缓存的英文是cache，最早其实指的是用于CPU和主存数据交互的。早年这块存储被称为高速缓存，最近已经听不到这个词了，不知道是不是淘汰了。因为缓存的读写速度要高于CPU低于主存，所以是用来过渡数据用的。CPU从缓存当中读取数据，
Python实现：详解LRU缓存淘汰算法
梦子微信
11-19 687
大家好，今天我们和大家聊一个非常常用的算法，叫做LRU。 LRU的英文全称是Least Recently Used，也即最不经常使用。我们看着好像挺迷糊的，其实这个含义要结合缓存一起使用。对于工程而言，缓存是非常非常重要的机制，尤其是在当下的互联网应用环境当中，起到的作用非常重要。为了便于大家更好地理解，我们从缓存的机制开始说起。 缓存 缓存的英文是cache，最早其实指的是用于CPU和主存数据交互的。早年这块存储被称为高速缓存，最近已经听不到这个词了，不知道是不是淘汰了。因为缓存的读写速度要高于CPU低于
LRU缓存淘汰算法（Python）
Darlewo
03-05 631
LRU缓存淘汰算法
Python functools.lru_cache 实现高速缓存及其原理 源码解析
wei_bo_cai的博客
08-08 2711
Python functools.lru_cache 实现高速缓存及其原理
【Leetcode】：LRU Cache_缓存淘汰算法LRU的设计与实现
懂幸福，爱生活
12-10 5691
内存淘汰算法是一个比较重要的算法，经常会被问道：如果让你设计一个LRU算法你会怎么做？尽可能的保持存取的高效。那么就依着这道算法题对LRU进行一个简单的介绍。
[leetcode]LRU Cache （python)
shiquxinkong的专栏
07-05 2769
LRU：最近最久未使用，为了得到这个最新最久的信息，需要一种策略来进行记录，如果加入类似时间戳式的字段，那么每次删除的时候，就必须通过遍历才能得到时间信息，或者对时间戳进行排序，但是无论哪种，都是需要额外的维护，维护成本都比较高。 广泛使用的策略是底层用双端队列来进行维护，双端使得在插入删除时操作更简单。而单单使用双端队列似乎还是不够，比如在get 时，还是需要顺序查找给定的key参数的，所以为
LRU算法——python实现
愤怒的小草
08-12 4200
在LeetCode上看到这么一道题，关于LRU算法是原理很简单，
如何使用Python内置缓存装饰器: @lru_cache，@cache 与 @cached_property
热门推荐
Python技术探索
06-28 1万+
Python 的内置库 functools 模块附带了@lru_cache，@cache, @cached_property 装饰器，可用于在代码中，对函数运算结果，类成员方法运算结果，进行缓存。上例中，每次运行函数时，lru_cache都会检查输入，如果之前运行过，则从缓存中返回结果 ，如果没有，则运行函数，并缓存结果。本文介绍了3种缓存工具的使用步骤，最后总结了对应的适用场景建议。
python实现LRU缓存机制
K's Blog
01-22 1203
最近师兄碰到一道面试题，一起坐了坐，题目本来是java的，但师兄面试的岗位其实是python，所以我们用python进行了实现。 题目： 运用你所掌握的数据结构，设计和实现一个LRU（最近最少使用）缓存机制。它应该支持以下操作：获取数据get和写入数据put。 具体思路与java实现见：https://zhuanlan.zhihu.com/p/34133067 下面是python实现： clas...
python 缓存装饰器
weixin_44732765的博客
05-23 830
参考https://www.cnblogs.com/faithfu/p/10365868.html cached_property缓存装饰器 class cached_property(object): """ Decorator that converts a method with a single self argument into a property cache...
python装饰器原理 | 常用装饰器使用(@cache, @lru_cache)
weixin_43646592的博客
02-22 4834
python装饰器原理 | 常用装饰器使用(@cache, @lru_cache)
Python中的@lru_cache装饰器
北辰
08-25 734
当缓存队列已满时，新的元素加入队列时，需要从现有队列中移除一个元素，LRU 策略就是将最近最少被访问的元素移除，从而腾出空间给新的元素。如果发生用户的删除或者新增时，我们再请求用户接口时仍然返回的是缓存中的数据，这样返回的信息就和我们数据库中的数据就会存在差异，所以当发生用户新增或者删除时，我们需要清除原先的缓存，然后再请求用户接口时可以重新加载缓存。特别注意：@lru_cache修饰器的使用位置要注意，不能将其放到@app.get修饰器的上面否则@lru_cache修饰器的缓存功能会失效。
python cache_Python 实现LRU Cache
weixin_39944595的博客
12-13 316
LRU: 最近最少使用算法。使用场景：在有限的空间存储对象时，当空间满时，按照一定的原则删除原有对象。常用的算法有LRU，FIFO，LFU。如memcached缓存系统即使用的LRU。LRU的算法是比较简单的，当对key进行访问时(一般有查询，更新，增加，在get()和set()两个方法中实现即可)时，将该key放到队列的最前端(或最后端)就行了，这样就实现了对key按其最后一次访问的时间降序(或...
python lru_cache缓存
大帅的博客
08-23 1072
@functools.lru_cache(maxsize=128,typed=False) @lru_cache装饰器可以提供缓存的功能，缓存maxsize组传入参数，在下次以相同参数调用时直接返回上一次的结果。用以节约高开销或I/O函数的调用时间。 举个列子： 普通计算斐波那契数列的递归代码 import timeit cnt = 0 def fib(n): if n == 1: global cnt cnt += 1 if n < ...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值