6

問題は基本的にこれで、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 クリップボードはアプリケーション全体のオブジェクトであり、 callback を使用するため、それに接続するとオブジェクトへの参照が保持されますself._clipboard_changed。

弱参照 (weakref モジュール) を使用してこれを回避する方法について議論していますが、まだ計画を立てていません。コールバックをシグナル登録に渡し、それを弱参照のように動作させる方法は誰でも知っています (ClipboardMonitor インスタンスがスコープ外にあるときにシグナル コールバックが呼び出された場合、それはノーオペレーションである必要があります)。

追加: GObject または GTK+ とは独立して言い回し:

弱参照セマンティクスを使用して、不透明なオブジェクトにコールバック メソッドをどのように提供しますか? 接続しているオブジェクトが範囲外になった場合は、削除する必要があり、コールバックはノーオペレーションとして機能する必要があります。接続先は、コネクタへの参照を保持してはなりません。

明確にするために：「デストラクタ/ファイナライザ」メソッドを呼び出す必要を明示的に避けたい

4

3 に答える 3

10

標準的な方法は、信号を切断することです。ただし、これには、オブジェクトを維持するコードによって明示的に呼び出されるデストラクタのようなメソッドがクラスに必要です。そうしないと、循環依存が発生するため、これが必要です。

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)

ご指摘のとおり、明示的な破棄を避けたい場合は、weakrefs が必要です。次のような弱いコールバック ファクトリを作成します。

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 を作成することはできません。実際weakref.ref(obj.method)には、weakref を作成した後、バインドされたメソッド オブジェクトを即座に破棄します。関数にweakrefを格納する必要があるかどうかも確認しませんでした...コードが静的であれば、おそらくそれを回避できると思います。
  • オブジェクト ラッパーは、弱参照が存在しなくなったことに気付くと、シグナル送信者から自身を削除します。これは、CallbackWrapper とシグナル送信側オブジェクトの間の循環依存を破棄するためにも必要です。
于 2009-09-01T22:27:56.683 に答える
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))
于 2009-11-12T23:30:29.877 に答える
1

（この回答は私の進捗状況を追跡します）

この 2 番目のバージョンも切断されます。gobjects 用の便利な関数がありますが、実際には、より一般的なケース (D-Bus シグナル コールバックと GObject コールバックの両方) でこのクラスが必要です。

とにかく、WeakCallback実装スタイルを何と呼ぶことができますか? これは弱いコールバックを非常にきれいにカプセル化したものですが、gobject/dbus の特殊化が目立たないように追加されています。これらの 2 つのケースに対して 2 つのサブクラスを作成するよりも優れています。

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)
于 2009-09-01T23:20:06.517 に答える