如何在Python中连接GObject信号，而不让其保持对连接者的引用？

Question

问题基本上是这样的，在Python的gobject和gtk绑定中。假设我们有一个类，在创建时会绑定到一个信号：

class ClipboardMonitor (object):
  def __init__(self):
    clip = gtk.clipboard_get(gtk.gdk.SELECTION_CLIPBOARD)
    clip.connect("owner-change", self._clipboard_changed)

现在的问题是，ClipboardMonitor的实例永远不会消失。gtk剪贴板是一个应用程序范围内的对象，连接到它会保持对这个对象的引用，因为我们使用了回调函数self._clipboard_changed。

我在考虑如何使用弱引用（weakref模块）来解决这个问题，但还没有想出一个具体的方案。有没有人知道如何将一个回调函数传递给信号注册，并让它像弱引用一样工作（如果在ClipboardMonitor实例超出范围时调用信号回调，它应该什么都不做）。

补充说明：不依赖于GObject或GTK+的说法：

你如何向一个不透明对象提供一个回调方法，并且具有弱引用的语义？如果连接的对象超出范围，它应该被删除，回调应该什么都不做；连接的对象不应该持有对连接器的引用。

为了澄清：我明确想避免调用“析构函数/终结器”方法。

Answer 1

其实我还没试过，不过：

class WeakCallback(object):
    """
    Used to wrap bound methods without keeping a ref to the underlying object.
    You can also pass in user_data and user_kwargs in the same way as with
    rpartial. Note that refs will be kept to everything you pass in other than
    the callback, which will have a weakref kept to it.
    """
    def __init__(self, callback, *user_data, **user_kwargs):
        self.im_self = weakref.proxy(callback.im_self, self._invalidated)
        self.im_func = weakref.proxy(callback.im_func)
        self.user_data = user_data
        self.user_kwargs = user_kwargs

    def __call__(self, *args, **kwargs):
        kwargs.update(self.user_kwargs)
        args += self.user_data
        self.im_func(self.im_self, *args, **kwargs)

    def _invalidated(self, im_self):
        """Called by the weakref.proxy object."""
        cb = getattr(self, 'cancel_callback', None)
        if cb is not None:
            cb()

    def add_cancel_function(self, cancel_callback):
        """
        A ref will be kept to cancel_callback. It will be called back without
        any args when the underlying object dies.
        You can wrap it in WeakCallback if you want, but that's a bit too
        self-referrential for me to do by default. Also, that would stop you
        being able to use a lambda as the cancel_callback.
        """
        self.cancel_callback = cancel_callback

def weak_connect(sender, signal, callback):
    """
    API-compatible with the function described in
    http://stackoverflow.com/questions/1364923/. Mostly used as an example.
    """
    cb = WeakCallback(callback)
    handle = sender.connect(signal, cb)
    cb.add_cancel_function(WeakCallback(sender.disconnect, handle))

Answer 2

(这个回答记录了我的进展)

这个第二版也会断开连接；我有一个方便的函数用于gobjects，但实际上我需要这个类来处理更一般的情况——既可以用于D-Bus信号回调，也可以用于GObject回调。

总之，大家可以怎么称呼这个WeakCallback的实现方式呢？它是一个非常干净的弱回调封装，但又不显眼地加上了gobject/dbus的特化。这样比起为这两种情况写两个子类要简单多了。

import weakref

class WeakCallback (object):
    """A Weak Callback object that will keep a reference to
    the connecting object with weakref semantics.

    This allows to connect to gobject signals without it keeping
    the connecting object alive forever.

    Will use @gobject_token or @dbus_token if set as follows:
        sender.disconnect(gobject_token)
        dbus_token.remove()
    """
    def __init__(self, obj, attr):
        """Create a new Weak Callback calling the method @obj.@attr"""
        self.wref = weakref.ref(obj)
        self.callback_attr = attr
        self.gobject_token = None
        self.dbus_token = None

    def __call__(self, *args, **kwargs):
        obj = self.wref()
        if obj:
            attr = getattr(obj, self.callback_attr)
            attr(*args, **kwargs)
        elif self.gobject_token:
            sender = args[0]
            sender.disconnect(self.gobject_token)
            self.gobject_token = None
        elif self.dbus_token:
            self.dbus_token.remove()
            self.dbus_token = None

def gobject_connect_weakly(sender, signal, connector, attr, *user_args):
    """Connect weakly to GObject @sender's @signal,
    with a callback in @connector named @attr.
    """
    wc = WeakCallback(connector, attr)
    wc.gobject_token = sender.connect(signal, wc, *user_args)

Answer 3

标准的做法是断开信号连接。不过，这需要在你的类里有一个类似析构函数的方法，这个方法需要由管理你对象的代码显式调用。这样做是必要的，因为如果不这样，你会遇到循环依赖的问题。

class ClipboardMonitor(object):
    [...]

    def __init__(self):
        self.clip = gtk.clipboard_get(gtk.gdk.SELECTION_CLIPBOARD)
        self.signal_id = self.clip.connect("owner-change", self._clipboard_changed)

    def close(self):
        self.clip.disconnect(self.signal_id)

正如你提到的，如果想避免显式销毁，就需要使用弱引用。我会写一个弱回调工厂，像这样：

import weakref

class CallbackWrapper(object):
    def __init__(self, sender, callback):
        self.weak_obj = weakref.ref(callback.im_self)
        self.weak_fun = weakref.ref(callback.im_func)
        self.sender = sender
        self.handle = None

    def __call__(self, *things):
        obj = self.weak_obj()
        fun = self.weak_fun()
        if obj is not None and fun is not None:
            return fun(obj, *things)
        elif self.handle is not None:
            self.sender.disconnect(self.handle)
            self.handle = None
            self.sender = None

def weak_connect(sender, signal, callback):
    wrapper = CallbackWrapper(sender, callback)
    wrapper.handle = sender.connect(signal, wrapper)
    return wrapper

(这段代码只是一个概念验证，能在我这儿工作——你可能需要根据自己的需求调整这段代码)。几点说明：

• 我把回调对象和函数分开存储。你不能简单地对绑定的方法创建弱引用，因为绑定的方法是非常临时的对象。实际上，weakref.ref(obj.method) 会在创建弱引用后立刻销毁绑定的方法对象。我没有检查是否需要对函数也存一个弱引用……我猜如果你的代码是静态的，可能就不需要了。
• 当对象包装器发现弱引用不再存在时，它会从信号发送者中移除自己。这也是为了消除 CallbackWrapper 和信号发送者对象之间的循环依赖。