Czy wątek + = operator jest bezpieczny w Pythonie?

Nie, ten kod jest absolutnie, ewidentnie nie threadsafe.

import threading

i = 0

def test():
    global i
    for x in range(100000):
        i += 1

threads = [threading.Thread(target=test) for t in range(10)]
for t in threads:
    t.start()

for t in threads:
    t.join()

assert i == 1000000, i

Konsekwentnie zawodzi.

I + = 1 rozwiązuje cztery opcody: load i, load 1, add the two, and store it back to i. interpreter Pythona przełącza aktywne wątki (zwalniając GIL z jednego wątku, aby inny wątek mógł go mieć) co 100 opcodów. (Oba te są szczegółami implementacji.) Warunek race występuje, gdy 100-opcode preemption dzieje się między załadowaniem i przechowywania, co pozwala na inny wątek, aby rozpocząć zwiększanie licznika. Gdy powróci do wątku zawieszonego, kontynuuje ze starą wartością " i " i cofa przyrosty uruchamiane przez inne wątki w międzyczasie.

Tworzenie threadsafe jest proste; dodaj blokadę:

#!/usr/bin/python
import threading
i = 0
i_lock = threading.Lock()

def test():
    global i
    i_lock.acquire()
    try:
        for x in range(100000):
            i += 1
    finally:
        i_lock.release()

threads = [threading.Thread(target=test) for t in range(10)]
for t in threads:
    t.start()

for t in threads:
    t.join()

assert i == 1000000, i

(Uwaga: będziesz potrzebował global c w każdej funkcji, aby Twój kod działał.)

Czy ten wątek kodu jest bezpieczny?

>>> c= 0
>>> def inc():
...     global c
...     c+= 1

>>> import dis
>>> dis.dis(inc)

  3           0 LOAD_GLOBAL              0 (c)
              3 LOAD_CONST               1 (1)
              6 INPLACE_ADD         
              7 STORE_GLOBAL             0 (c)
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE        

Aby jedna nić mogła dostać się do indeksu 6 z C i 1 załadowanym, oddać GIL i wpuścić inną nić, która wykonuje inc i usypia, zwracając GIL do pierwszego wątku, który teraz ma złą wartość.

W każdym razie atomic jest szczegółem implementacji, na którym nie powinieneś polegać. Bajtowe kody mogą się zmieniać w przyszłych wersjach Cpythona, a wyniki będą zupełnie inne w innych implementacjach Pythona, które nie opierają się na GIL. Jeśli potrzebujesz zabezpieczenia gwintu, potrzebujesz mechanizmu blokującego.

Dla pewności polecam użycie zamka:

import threading

class ThreadSafeCounter():
    def __init__(self):
        self.lock = threading.Lock()
        self.counter=0

    def increment(self):
        with self.lock:
            self.counter+=1


    def decrement(self):
        with self.lock:
            self.counter-=1

Zsynchronizowany dekorator może również pomóc w utrzymaniu czytelnego kodu.

Łatwo udowodnić, że Twój kod jest nie bezpieczny dla wątków . Możesz zwiększyć prawdopodobieństwo, że zobaczysz stan wyścigu, używając snu w krytycznych częściach(to po prostu symuluje powolny procesor). Jeśli jednak używasz kodu wystarczająco długo, powinieneś ostatecznie zobaczyć stan wyścigu niezależnie od tego.

from time import sleep
c = 0

def increment():
  global c
  c_ = c
  sleep(0.1)
  c = c_ + 1

def decrement():
  global c
  c_ = c
  sleep(0.1)
  c  = c_ - 1

Krótka odpowiedź: Nie.

Długa odpowiedź: ogólnie nie.

Podczas gdy Gil Cpythona tworzy pojedyncze opcody thread-safe, nie jest to ogólne zachowanie. Nie można zakładać, że nawet proste operacje, takie jak dodawanie, są instrukcją atomową. Dodanie może być wykonane tylko w połowie, gdy działa inny wątek.

I jak tylko twoje funkcje uzyskają dostęp do zmiennej w więcej niż jednym kodzie, Twoje bezpieczeństwo wątku zniknie. Możesz wygenerować bezpieczeństwo wątku, jeśli owijasz swoje ciała funkcyjne w zamki . Należy jednak pamiętać, że blokady mogą być kosztowne obliczeniowo i mogą generować blokady.

Jeśli naprawdę chcesz, aby Twój kod nie był bezpieczny dla wątków i masz duże szanse na to, że "złe" rzeczy faktycznie się wydarzą, bez tego, że spróbujesz dziesięć tysięcy razy (lub jeden raz, gdy naprawdę nie chcesz, aby "złe" rzeczy się wydarzyły), możesz "jitter" kodu za pomocą explicit sleeps:

def íncrement():
    global c
    x = c
    from time import sleep
    sleep(0.1)
    c = x + 1

Czy jesteś pewien, że funkcje increment i decrement wykonują się bez błędu?

Myślę, że powinno to wywołać UnboundLocalError, ponieważ musisz wyraźnie powiedzieć Pythonowi, że chcesz użyć zmiennej globalnej o nazwie 'c'.

Więc zmień przyrost ( także przyrost) na następujący:

def increment():
    global c
    c += 1

Myślę, że Twój kod jest niebezpieczny. Ten artykuł o mechanizmach synchronizacji wątków w Pythonie może być pomocny.