Python Cookbook

Synchronizing All Methods in an Object

Credit: André Bjärby

Problem

You want to share an object among multiple threads, but to avoid conflicts you need to ensure that only one thread at a time is inside the object, possibly excepting some methods for which you want to hand-tune locking behavior.

Solution

Java offers such synchronization as a built-in feature, while in Python you have to program it explicitly using reentrant locks, but this is not all that hard:

import types

def _get_method_names(obj):
    """ Get all methods of a class or instance, inherited or otherwise. """
    if type(obj) == types.InstanceType:
        return _get_method_names(obj._ _class_ _)
    elif type(obj) == types.ClassType:
        result = []
        for name, func in obj._ _dict_ _.items(  ):
            if type(func) == types.FunctionType:
                result.append((name, func))
        for base in obj._ _bases_ _:
            result.extend(_get_method_names(base))
        return result


class _SynchronizedMethod:
    """ Wrap lock and release operations around a method call. """

    def _ _init_ _(self, method, obj, lock):
        self._ _method = method
        self._ _obj = obj
        self._ _lock = lock

    def _ _call_ _(self, *args, **kwargs):
        self._ _lock.acquire(  )
        try:
            return self._ _method(self._ _obj, *args, **kwargs)
        finally:
            self._ _lock.release(  ) class SynchronizedObject: """ Wrap all methods of an object into _SynchronizedMethod instances. """ def _ _init_ _(self, obj, ignore=[], lock=None): import threading # You must access _ _dict_ _ directly to avoid tickling _ _setattr_ _ self._ _dict_ _['_SynchronizedObject_ ...