Sont Python variables d'instance de thread-safe?
OK, vérifier les codes suivants de la première:
class DemoClass():
def __init__(self):
#### I really want to know if self.Counter is thread-safe.
self.Counter = 0
def Increase(self):
self.Counter = self.Counter + 1
def Decrease(self):
self.Counter = self.Counter - 1
def DoThis(self):
while True:
Do something
if A happens:
self.Increase()
else:
self.Decrease()
time.sleep(randomSecs)
def DoThat(self):
while True:
Do other things
if B happens:
self.Increase()
else:
self.Decrease()
time.sleep(randomSecs)
def ThreadSafeOrNot(self):
InterestingThreadA = threading.Thread(target = self.DoThis, args = ())
InterestingThreadA.start()
InterestingThreadB = threading.Thread(target = self.DoThat, args = ())
InterestingThreadB.start()
Je suis confronté à la même situation que ci-dessus. Je veux vraiment savoir si c'est thread-safe pour self.Counter
, eh bien, si non, quelles options dois-je avoir? Je ne peux que penser à threading.RLock()
pour verrouiller cette ressource, une meilleure idée?
OriginalL'auteur Shane | 2011-11-29
Vous devez vous connecter pour publier un commentaire.
Vous pouvez utiliser des Verrous, RLocks, les Sémaphores, les Conditions, les Événements et les Files d'attente.
Et cet article m'a aidé à beaucoup.
Check it out: Laurent Luce Blog
C'est à quel sujet? :p
OriginalL'auteur aayoubi
À l'aide de l'exemple de champ
self.Counter
est "thread-safe" ou "atomique". La lecture ou l'affectation d'un unique valeur - même quand il en a besoin de 4 octets en mémoire, vous n'obtiendrez jamais de demi-valeur modifiée. Mais l'opérationself.Counter = self.Counter + 1
n'est pas parce qu'il lit la valeur et puis l'écrit - un autre thread pourrait changer la valeur du champ lorsqu'il a été lu, et avant qu'il est écrit au dos.De sorte que vous besoin de protéger l'ensemble de l'opération avec un cadenas.
Depuis le corps de la méthode est fondamentalement l'ensemble de l'opération, vous pouvez utiliser un décorateur pour ce faire. Voir cette réponse par un exemple: https://stackoverflow.com/a/490090/34088
Je suppose qu'il signifie, comme
self.Counter = Value
sont thread-safe. Vérifiez cet article, je viens de trouver: effbot.org/pyfaq/...L'attribution d'une valeur n'est pas thread-safe. Disons que vous avez soi-même.Compteur=1, suivie d'une auto.Compteur=2 alors x=auto.Le compteur. Alors x peut être 1 ou 2 selon le fil de commutation, ce qui rend l'attribution d'une valeur à ne pas thread-safe.
Ce que j'ai dit, c'est que un cession est atomique (sauf pour la version 64 bits). Voir stackoverflow.com/questions/4756536/...
OriginalL'auteur Aaron Digulla
Non, il n'est pas thread-safe - les deux fils sont essentiellement modifiant la même variable simultanément. Et oui, la solution est l'un des mécanismes de verrouillage dans le
threading
module.BTW,
self.Counter
est un variable d'instance, pas un variable de classe.OriginalL'auteur Eli Bendersky
auto.Compteur est une variable d'instance, de sorte que chaque thread possède la copie.
Si vous déclarez la variable en dehors de __init (), il sera une variable de classe.
Toutes les instances de la classe partageront cette instance.
Être très prudent avec ça. Il peut ajouter un peu de complexité. Vous pourriez avoir à faire une certaine forme de verrouillage.
oui, c'est le point. L'OP a voulu savoir si les variables d'instance ont été thread-safe ou pas.
OriginalL'auteur Jack Mason