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=275552En 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
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
. 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
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!