Czy modyfikuje zmienną klasy w python threadsafe?

Question

czytałem this question (który nie trzeba czytać, bo będę kopiować to, co jest tam ... Po prostu chciałem dać ci pokazać moją inspirację) ...

Więc, jeśli mam klasy, która się liczy ilu przypadków powstały:

class Foo(object): 
    instance_count = 0 
    def __init__(self): 
    Foo.instance_count += 1 

Moje pytanie brzmi, czy mogę tworzyć obiekty Foo w wielu wątków, jest instance_count będzie prawidłowa? Czy zmienne klasy można bezpiecznie modyfikować z wielu wątków?

Answer 1

Nie jest to wątek bezpieczny nawet w CPython. Spróbuj to zobaczyć na własne oczy:

import threading 

class Foo(object): 
    instance_count = 0 

def inc_by(n): 
    for i in xrange(n): 
     Foo.instance_count += 1 

threads = [threading.Thread(target=inc_by, args=(100000,)) for thread_nr in xrange(100)] 
for thread in threads: thread.start() 
for thread in threads: thread.join() 

print(Foo.instance_count) # Expected 10M for threadsafe ops, I get around 5M 

Powodem jest to, że podczas INPLACE_ADD jest atomowy pod GIL, atrybut jest nadal załadowany i przechowywania (patrz dis.dis (Foo .__ init__)). Użyj blokady do serializacji dostępu do zmiennej klasy:

Foo.lock = threading.Lock() 

def interlocked_inc(n): 
    for i in xrange(n): 
     with Foo.lock: 
      Foo.instance_count += 1 

threads = [threading.Thread(target=interlocked_inc, args=(100000,)) for thread_nr in xrange(100)] 
for thread in threads: thread.start() 
for thread in threads: thread.join() 

print(Foo.instance_count) 

Answer 2

Powiedziałbym, że jest bezpieczny dla wątków, przynajmniej na podstawie implementacji CPython. GIL sprawi, że wszystkie twoje "wątki" będą uruchamiane sekwencyjnie, więc nie będą mogły zepsuć twojej liczby referencyjnej.

Answer 3

Nie jest to bezpieczne dla wątków. Kilka dni temu spotkałem się z podobnym problemem i postanowiłem wdrożyć zamek dzięki dekoratorowi. Zaletą jest to, że kod jest czytelny:

 
def threadsafe_function(fn): 
    """decorator making sure that the decorated function is thread safe""" 
    lock = threading.Lock() 
    def new(*args, **kwargs): 
     lock.acquire() 
     try: 
      r = fn(*args, **kwargs) 
     except Exception as e: 
      raise e 
     finally: 
      lock.release() 
     return r 
    return new 

class X: 
    var = 0 

    @threadsafe_function  
    def inc_var(self): 
     X.var += 1  
     return X.var