Sta modificando una variabile di classe in python threadsafe?

Question

Stavo leggendo this question (che non c'è bisogno di leggere perché io copio quello che c'è ... volevo solo per dare spettacolo la mia ispirazione) ...

Quindi, se ho una classe che conta quante istanze sono state create:

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

La mia domanda è, se creo oggetti Foo in più thread, è instance_count sta per essere corretto? Le variabili di classe sono sicure da modificare da più thread?

Answer 1

Non è protetto da thread anche su CPython. Provate a vedere di persona:

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 

La ragione è che, mentre INPLACE_ADD è atomica sotto GIL, l'attributo è ancora caricato e memorizzare (vedi dis.dis (Foo .__ init__)). Utilizzare un blocco per serializzare l'accesso alla variabile di classe:

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

Direi che è thread-safe, almeno per l'implementazione CPython. Il GIL farà in modo che tutti i tuoi "thread" vengano eseguiti in modo sequenziale, in modo che non possano interferire con il numero di riferimenti.

Answer 3

No, non è thread-safe. Ho affrontato un problema simile qualche giorno fa e ho scelto di implementare il lucchetto grazie a un decoratore. Il vantaggio è che rende leggibile il codice:

 
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