66

如何functools.lru_cache在不泄漏内存的情况下使用内部类？

在下面的最小示例中，foo尽管超出范围并且没有引用者（除了 ），但不会释放实例lru_cache。

from functools import lru_cache
class BigClass:
    pass
class Foo:
    def __init__(self):
        self.big = BigClass()
    @lru_cache(maxsize=16)
    def cached_method(self, x):
        return x + 5

def fun():
    foo = Foo()
    print(foo.cached_method(10))
    print(foo.cached_method(10)) # use cache
    return 'something'

fun()

但是foo因此foo.big(a BigClass) 还活着

import gc; gc.collect()  # collect garbage
len([obj for obj in gc.get_objects() if isinstance(obj, Foo)]) # is 1

这意味着Foo/BigClass实例仍然驻留在内存中。即使删除Foo(del Foo) 也不会释放它们。

为什么要lru_cache保留实例？缓存不使用一些哈希而不是实际对象吗？

lru_cache在类中使用 s的推荐方式是什么？

我知道两种解决方法： 使用每个实例缓存或使缓存忽略对象（但这可能会导致错误的结果）

4

5 回答 5

42

这不是最干净的解决方案，但对程序员来说是完全透明的：

import functools
import weakref

def memoized_method(*lru_args, **lru_kwargs):
    def decorator(func):
        @functools.wraps(func)
        def wrapped_func(self, *args, **kwargs):
            # We're storing the wrapped method inside the instance. If we had
            # a strong reference to self the instance would never die.
            self_weak = weakref.ref(self)
            @functools.wraps(func)
            @functools.lru_cache(*lru_args, **lru_kwargs)
            def cached_method(*args, **kwargs):
                return func(self_weak(), *args, **kwargs)
            setattr(self, func.__name__, cached_method)
            return cached_method(*args, **kwargs)
        return wrapped_func
    return decorator

它采用与 完全相同的参数lru_cache，并且工作方式完全相同。但是，它永远不会传递self给lru_cache而是使用 per-instance lru_cache。

于 2015-11-12T13:26:14.203 回答
18

我将介绍methodtools这个用例。

pip install methodtools安装https://pypi.org/project/methodtools/

然后，您的代码只需将 functools 替换为 methodtools 即可工作。

from methodtools import lru_cache
class Foo:
    @lru_cache(maxsize=16)
    def cached_method(self, x):
        return x + 5

当然 gc 测试也返回 0 。

于 2019-05-05T10:00:25.027 回答
8

python 3.8在模块中引入了cached_property装饰器。functools测试时，它似乎不保留实例。

如果您不想更新到 python 3.8，您可以使用源代码。您只需要导入RLock和创建_NOT_FOUND对象。意义：

from threading import RLock

_NOT_FOUND = object()

class cached_property:
    # https://github.com/python/cpython/blob/v3.8.0/Lib/functools.py#L930
    ...
于 2019-10-28T14:18:03.013 回答
7

简单的包装解决方案

这是一个包装器，它将保留对实例的弱引用：

import functools
import weakref

def weak_lru(maxsize=128, typed=False):
    'LRU Cache decorator that keeps a weak reference to "self"'
    def wrapper(func):

        @functools.lru_cache(maxsize, typed)
        def _func(_self, *args, **kwargs):
            return func(_self(), *args, **kwargs)

        @functools.wraps(func)
        def inner(self, *args, **kwargs):
            return _func(weakref.ref(self), *args, **kwargs)

        return inner

    return wrapper

例子

像这样使用它：

class Weather:
    "Lookup weather information on a government website"

    def __init__(self, station_id):
        self.station_id = station_id

    @weak_lru(maxsize=10)
    def climate(self, category='average_temperature'):
        print('Simulating a slow method call!')
        return self.station_id + category

何时使用

由于weakrefs 增加了一些开销，因此您只想在实例很大并且应用程序不能等待较旧的未使用调用从缓存中老化时才使用它。

为什么这更好

与其他答案不同，我们只有一个类缓存，而不是每个实例一个缓存。如果您想从最近最少使用的算法中获得一些好处，这一点很重要。对于每个方法使用一个缓存，您可以设置maxsize以便总内存使用是有界的，而与活动的实例数量无关。

处理可变属性

如果方法中使用的任何属性是可变的，请务必添加_ eq _()和_ hash _()方法：

class Weather:
    "Lookup weather information on a government website"

    def __init__(self, station_id):
        self.station_id = station_id

    def update_station(station_id):
        self.station_id = station_id

    def __eq__(self, other):
        return self.station_id == other.station_id

    def __hash__(self):
        return hash(self.station_id)
于 2021-06-20T05:39:57.480 回答
5

这个问题的一个更简单的解决方案是在构造函数中而不是在类定义中声明缓存：

from functools import lru_cache
import gc

class BigClass:
    pass
class Foo:
    def __init__(self):
        self.big = BigClass()
        self.cached_method = lru_cache(maxsize=16)(self.cached_method)
    def cached_method(self, x):
        return x + 5

def fun():
    foo = Foo()
    print(foo.cached_method(10))
    print(foo.cached_method(10)) # use cache
    return 'something'
    
if __name__ == '__main__':
    fun()
    gc.collect()  # collect garbage
    print(len([obj for obj in gc.get_objects() if isinstance(obj, Foo)]))  # is 0
于 2021-07-27T18:41:41.320 回答