Are classmethods thread safe?

Question

I am working on a class which operates in a multithreaded environment, and looks something like this (with excess noise removed):

class B:

    @classmethod
    def apply(cls, item):
        cls.do_thing(item)

    @classmethod
    def do_thing(cls, item)
        'do something to item'

    def run(self):
        pool = multiprocessing.Pool()
        for list_of_items in self.data_groups:
            pool.map(list_of_items, self.apply)

My concern is that two threads might call apply or do_thing at the same time, or that a subclass might try to do something stupid with cls in one of these functions. I could use staticmethod instead of classmethod, but calling do_thing would become a lot more complicated, especially if a subclass reimplements one of these but not the other. So my question is this: Is the above class thread-safe, or is there a potential problem with using classmethods like that?

Answer 1

Whether a method is thread safe or not depends on what the method does.

Working with local variables only is thread safe. But when you change the same non local variable from different threads, it becomes unsafe.

‘do something to item’ seems to modify only the given object, which is independent from any other object in the list, so it should be thread safe.

If the same object is in the list several times, you may have to think about making the object thread safe. That can be done by using with self.object_scope_lock: in every method which modifies the object.

Anyway, what you are doing here is using processes instead of threads. In this case the objects are pickled and send through a pipe to the other process, where they are modified and send back. In contrast to threads processes do not share memory. So I don’t think using a lock in the class-method would have an effect.

http://docs.python.org/3/library/threading.html?highlight=threading#module-threading