Zdarzenia są częstym scenariuszem dla słabych odniesień.

Problem

Rozważmy parę obiektów: emiter i Odbiornik. Odbiornik ma krótszą żywotność niż emiter.

Możesz wypróbować taką implementację:

class Emitter(object):

    def __init__(self):
        self.listeners = set()

    def emit(self):
        for listener in self.listeners:
            # Notify
            listener('hello')


class Receiver(object):

    def __init__(self, emitter):

        emitter.listeners.add(self.callback)

    def callback(self, msg):
        print 'Message received:', msg


e = Emitter()
l = Receiver(e)
e.emit() # Message received: hello

Jednak w tym przypadku emiter zachowuje odniesienie do metody wiązanej callback, która zachowuje odniesienie do odbiornika. Więc emiter utrzymuje Odbiornik przy życiu:

# ...continued...

del l
e.emit() # Message received: hello

Przez cały okres istnienia aplikacji można wywoływać wiele okien dialogowych i nie chcemy, aby ich odbiorniki były nadal rejestrowane wewnątrz emitera długo po zamknięciu okna. To byłby wyciek pamięci.

Ręczne usuwanie wywołań zwrotnych jest jedną z opcji (równie kłopotliwych), używanie słabych odwołań jest kolejny.

Rozwiązanie

Jest ładna Klasa WeakSet, która wygląda jak normalny zestaw, ale przechowuje swoje elementy używając słabych referencji i nie przechowuje ich już, gdy są uwolnione.

def __init__(self):
    self.listeners = weakref.WeakSet()

I uruchomić ponownie:

e = Emitter()
l = Receiver(e)
e.emit()
del l
e.emit()

Sprawmy, aby odbiornik (nie emiter tym razem) zachowywał silne odniesienie do tego wywołania zwrotnego:

class Receiver(object):

    def __init__(self, emitter):

        # Create the bound method object
        cb = self.callback

        # Register it
        emitter.listeners.add(cb)
        # But also create an own strong reference to keep it alive
        self._callbacks = set([cb])

Teraz możemy obserwować oczekiwane zachowanie: emiter utrzymuje callback tylko tak długo, jak długo Odbiornik żyje.

e = Emitter()
l = Receiver(e)
assert len(e.listeners) == 1

del l
import gc; gc.collect()
assert len(e.listeners) == 0

Pod maską

Zauważ, że musiałem umieścić gc.collect() tutaj, aby upewnić się, że odbiornik jest naprawdę wyczyszczone natychmiast. Jest tu potrzebna, bo teraz jest cykl silnych odniesień: metoda związana odnosi się do odbiornika i odwrotnie.

Nie jest to bardzo złe; oznacza to tylko, że czyszczenie odbiornika zostanie odroczone do następnego uruchomienia garbage collector. Cykliczne odniesienia nie mogą być czyszczone przez prosty mechanizm zliczania odniesień.

Jeśli naprawdę chcesz, możesz usunąć silny cykl odniesienia, zastępując metodę bound niestandardowym obiektem funkcji, który zachowałby jej self jako słabe odniesienie.

def __init__(self, emitter):

    # Create the bound method object
    weakself = weakref.ref(self)
    def cb(msg):
        self = weakself()
        self.callback(msg)

    # Register it
    emitter.listeners.add(cb)
    # But also create an own strong reference to keep it alive
    self._callbacks = set([cb])

Włóżmy tę logikę do helpera funkcja:

def weak_bind(instancemethod):

    weakref_self = weakref.ref(instancemethod.im_self)
    func = instancemethod.im_func

    def callback(*args, **kwargs):
        self = weakref_self()
        bound = func.__get__(self)
        return bound(*args, **kwargs)

    return callback

class Receiver(object):

    def __init__(self, emitter):

        cb = weak_bind(self.callback)

        # Register it
        emitter.listeners.add(cb)
        # But also create an own strong reference to keep it alive
        self._callbacks = set([cb])

Teraz nie ma cyklu silnych referencji, więc kiedy Receiver zostanie uwolniona, funkcja zwrotna zostanie również uwolniona (i usunięta z emitera WeakSet) natychmiast, bez potrzeby pełnego cyklu GC.

 - Weak references is an important concept in python, which is missing
   in languages likes Java(java 1.5).
 - In Observer design pattern, generally Observable Object must maintain
   weak references to the Observer object.

   eg. A emits an event done() and B registers with A that, it want to
   listen to event done(). Thus, whenever done() is emitted, B is
   notified. But If B isn't required in application, then A must not
   become an hinderance in the garbage collection in A(since A hold the
   reference to B). Thus, if A has hold weak reference to B, and when
   all the references to A are away, then B will be garbage collected.
 - It's also very useful in implementing caches.