Python-functools lru_cache mit Klassen-Methoden: Freigabe-Objekt

Wie kann ich functools' lru_cache im inneren Klassen ohne Speicherverlust?
Im folgenden minimalen Beispiel die foo Instanz wird nicht freigegeben werden, obwohl aus Umfang und ohne referrer (andere als die 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()

Aber foo und damit foo.big (a BigClass) sind noch am Leben

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

Das bedeutet, dass Foo/BigClass Instanzen sind immer noch wohnhaft in Speicher. Auch das löschen Foo (del Foo) wird Sie nicht loslassen wollen.

Warum ist lru_cache holding auf, um die Instanz überhaupt? Nicht die cache-Nutzung einige hash und nicht das eigentliche Objekt?

Was ist die empfohlene Weise verwenden lru_caches im inneren Klassen?

Kenne ich zwei workarounds:
Verwenden Sie pro Instanz caches oder den cache ignorieren-Objekt (was zu falschen Ergebnissen führen kann, obwohl)

InformationsquelleAutor televator | 2015-11-12
  1. 30

    Dies ist nicht die sauberste Lösung, aber es ist völlig transparent für den Programmierer:

    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

    Er nimmt dieselben Parameter wie lru_cache, und funktioniert genauso. Aber es geht niemals self zu lru_cache und verwendet stattdessen eine pro-Instanz lru_cache.

    • Dies hat die leichte Fremdheit, dass die Funktion auf die Instanz wird nur dann ersetzt, durch die caching-wrapper auf dem ersten Aufruf. Auch die Cache-wrapper-Funktion ist nicht gesalbt mit lru_cache's cache_clear/cache_info Funktionen (Umsetzung, die war, wo ich rempelte an Erster Stelle).
    • Dies scheint nicht zu funktionieren für __getitem__. Irgendwelche Ideen, warum ? Es funktioniert, wenn Sie anrufen instance.__getitem__(key) aber nicht instance[key].
    InformationsquelleAutor orlp
  2. 3

    Stelle ich methodtools für diesen Anwendungsfall.

    pip install methodtools zu installieren https://pypi.org/project/methodtools/

    Dann ist dein code funktioniert nur durch den Austausch functools zu methodtools.

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

    Natürlich der gc testen, gibt auch 0 zu.

    • warum methodtools wenn es bereits ring?
    • Sie können entweder eine. methodtools.lru_cache verhält sich genau wie functools.lru_cache durch die Wiederverwendung functools.lru_cache im inneren, während ring.lru schlägt vor, mehr features durch reimplementing lru Lagerung in python.
    • methodtools.lru_cache auf eine Methode verwendet eine getrennte Lagerung für jede Instanz der Klasse, während die Speicherung von ring.lru teilen sich alle Instanzen der Klasse.
    InformationsquelleAutor youknowone
Schreibe einen Kommentar