Analyse des malentendus sur l'utilisation du blocage (join) et du verrouillage (Lock) dans le multithreading Python

Cet article est principalement destiné à chacun de détailler Il introduit des malentendus sur le blocage de la jointure et du verrouillage dans le multithread Python, qui a une certaine valeur de référence. Les amis intéressés peuvent se référer à

À propos du blocage du fil principal

Incorrect. utilisation des fonctions join

Thread.join() pour bloquer le thread principal, c'est-à-dire que lorsque le thread enfant ne revient pas, le thread principal attend son retour avant de continuer l'exécution.

La jointure ne peut pas être utilisée avec un démarrage en boucle
Ce qui suit est le code d'erreur. Le code crée 5 threads, puis utilise une boucle pour activer les threads. Après activation, il bloque le thread principal.

threads = [Thread() for i in range(5)]
for thread in threads:
  thread.start()
  thread.join()

Processus d'exécution :

1. Dans la première boucle, le thread principal active le thread 1 via la fonction start, et le thread 1 effectue les calculs.
2. Puisque la fonction start ne bloque pas le thread principal, pendant que le thread 1 effectue des opérations, le thread principal exécute la fonction de jointure vers le bas
3. est bloqué par le thread 1. Avant que le thread 1 ne renvoie le résultat, le thread principal ne peut pas exécuter le cycle suivant
4. Une fois le calcul terminé, débloquez le thread principal
5. le cycle suivant, active le thread 2 et est bloqué par celui-ci...

En faisant des allers-retours ainsi, on voit que les cinq threads qui étaient censés être concurrents sont ici devenus des files d'attente séquentielles, et l'efficacité est la même que celle d'un seul thread.

L'utilisation correcte de join

Utilisez deux boucles pour traiter le start et join fonctions respectivement. La concurrence peut être obtenue.

threads = [Thread() for i in range(5)]
for thread in threads:
  thread.start()
for thread in threads:
  thread.join()

time.sleep remplace join pour le débogage

J'ai J'ai déjà vu un tel code dans certains projets, en utilisant time.sleep au lieu de join pour bloquer manuellement le thread principal
Avant le retour de tous les threads enfants, le thread principal tombe dans une boucle sans fin et ne peut pas sortir.

for thread in threads:
  thread.start()
while 1:
  if thread_num == 0:
    break
  time.sleep(0.01)

À propos du verrouillage des threads (threading.Lock)

Le processeur monocœur + PIL a-t-il toujours besoin de verrous ?

Opération non atomiquecount = count + 1 Théoriquement, il est dangereux pour les threads
Utilisez 3 threads pour effectuer l'opération ci-dessus en même temps. La valeur de la variable globale compte et vérifiez le programme. résultat de l'exécution.
Si le résultat est correct, cela signifie qu'il n'y a pas de conflit de thread

Utilisez le code suivant pour tester

# -*- coding: utf-8 -*-
import threading
import time
count = 0
class Counter(threading.Thread):
  def __init__(self, name):
    self.thread_name = name
    super(Counter, self).__init__(name=name)
  def run(self):
    global count
    for i in xrange(100000):
      count = count + 1
counters = [Counter('thread:%s' % i) for i in range(5)]
for counter in counters:
  counter.start()
time.sleep(5)
print 'count=%s' % count

Résultats d'exécution :

count=275552

En fait, les résultats de chaque exécution sont différents et incorrects, ce qui prouve que le CPU monocœur + PIL est toujours ne peut pas garantir la sécurité des threads et nécessite un verrouillage

Corriger le code après le verrouillage :

# -*- coding: utf-8 -*-
import threading
import time
count = 0
lock = threading.Lock()
class Counter(threading.Thread):
  def __init__(self, name):
    self.thread_name = name
    self.lock = threading.Lock()
    super(Counter, self).__init__(name=name)
  def run(self):
    global count
    global lock
    for i in xrange(100000):
      lock.acquire()
      count = count + 1
      lock.release()


counters = [Counter('thread:%s' % i) for i in range(5)]

for counter in counters:
  counter.start()

time.sleep(5)
print 'count=%s' % count

Résultat :

count=500000

Faites attention à la nature globale du verrou

Il s'agit d'un simple problème de syntaxe Python, mais il y a des problèmes lorsque la logique est complexe Peut être ignoré.

Assurez-vous que le verrou est partagé par plusieurs sous-threads, c'est-à-dire ne créez pas de verrou dans une sous-classe de Thread

Les éléments suivants sont

. codes d'erreur

# -*- coding: utf-8 -*-

import threading
import time
count = 0
# lock = threading.Lock() # 正确的声明位置
class Counter(threading.Thread):
  def __init__(self, name):
    self.thread_name = name
    self.lock = threading.Lock() # 错误的声明位置
    super(Counter, self).__init__(name=name)
  def run(self):
    global count
    for i in xrange(100000):
      self.lock.acquire()
      count = count + 1
      self.lock.release()
counters = [Counter('thread:%s' % i) for i in range(5)]

for counter in counters:
  print counter.thread_name
  counter.start()

time.sleep(5)
print 'count=%s' % count

Recommandations associées :

Explication détaillée des verrous de synchronisation dans threads python

Explication détaillée de l'utilisation des événements dans le multi-threading python

Implémentation du pool de threads python

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!