Python multithreading

«Dans un processus, une unité d'exécution est connue sous le nom de thread. En déplaçant rapidement l'attention du CPU entre les threads, de nombreux threads peuvent être exécutés simultanément dans un processus appelé multithreading (également appelé commutation de contexte). Les bases de Python Multithreading seront couvertes dans cet article. Pour votre aide, nous fournirons également une variété d'exemples."

Multithreading à python

Le multithreading est une technique de threading utilisée dans la programmation Python pour exécuter de nombreux threads en même temps. De plus, il permet le partage de son espace de données avec les threads primaires à l'intérieur d'un processus, qui communiquent et partagent des informations plus facilement que des processus séparés. L'objectif du multithreading est de réaliser de nombreux processus simultanément, ce qui améliore le rendu et les performances de l'application.

Il s'agit d'une méthode très pratique pour accélérer et améliorer la fonctionnalité d'une application. En utilisant le multithreading, un programmeur peut décomposer les tâches d'application en travaux plus petits et exécuter plusieurs instances du programme à la fois. Il permet aux threads de communiquer entre eux et de partager les ressources du processeur, y compris la mémoire, les fichiers et les données. De plus, cela rend les utilisateurs plus disposés à continuer à utiliser un programme même lorsqu'une section de celle-ci est bloquée ou trop longue.

Exemple 1

Voici un simple programme Python pour le multithreading. Regardons un programme Python qui a deux classes, «Python_demo» et «Python_lesson."Examinons cet exemple de code en détail.

Deux de nos classes utilisent des techniques similaires. La sortie de la fonction d'exécution de l'objet de la première classe lorsqu'elle est construite et imprimé la phrase «démo python» quatre fois. Le mot «leçon python» apparaît quatre fois lorsque nous répétons le processus pour la deuxième classe.

classe Python_demo:
def run (self):
Pour I à portée (4):
print ("Demo Python")
classe Python_lesson:
def run (self):
Pour I à portée (4):
imprimer ("leçon python")
first_obj = python_demo ()
second_obj = python_lesson ()
first_obj.courir()
second_obj.courir()

Le résultat si nous exécutons ce programme est le suivant. La démo python et la leçon Python sont indiqués quatre fois de suite, comme vous pouvez le voir. En conséquence, le fil principal est l'endroit où ce programme fonctionne. Chaque programme contient le fil principal. Dans ce cas, les deux opérations sont effectuées dans une séquence.

Exemple 2

Nous utiliserons le module de filetage de Python comme exemple. Nous pourrions comprendre la nécessité du multithreading si nous considérons le premier scénario. Cela implique que les deux procédures doivent être utilisées simultanément. La classe de threads et le package de filetage de Python peuvent être utilisés pour y parvenir. Essayons de penser à quelque chose. Maintenant que le multithreading est présent, l'échantillon de programme a été mis à jour. De plus, chaque classe a été exécutée comme son propre thread à l'aide de la classe de threads.

Nous avons également fait une différence en n'appelant pas directement la méthode d'exécution. Au lieu de cela, nous utilisons la méthode de démarrage, qui est essentiellement le mécanisme de mise en œuvre du filetage.

Lorsque nous appliquons la méthode de démarrage, la fonction d'exécution est instantanément appelée en arrière-plan. Nous exécutons actuellement le thread principal par défaut. Deux fils d'enfants, First OBJ et Second OBJ, sont formés lorsque les méthodes de démarrage sont appelées.

à partir de l'importation de filetage *
classe Python_demo (thread):
def run (self):
Pour I à portée (4):
print ("Demo Python")
classe Python_lesson (thread):
def run (self):
Pour I à portée (4):
imprimer ("leçon python")
first_obj = python_demo ()
second_obj = python_lesson ()
first_obj.commencer()
second_obj.commencer()

Ces ajustements entraînent la sortie affichée ci-dessous. Maintenant que l'application est en cours d'exécution, le multithreading peut être vu. Nous pouvons voir que plusieurs mots sont regroupés ensemble, malgré le fait que la «démo python» et la «leçon python» sont deux phrases distinctes. Cela résulte d'une collision. Cela se produit à la suite de deux threads (first_obj et second_obj) essayant d'exécuter simultanément sur le CPU en raison de la vitesse excessive du processeur.

Exemple 3

Les planificateurs du système d'exploitation spécifient l'heure d'exécution. Dans cet exemple, les instructions sont effectuées par le logiciel plus d'une fois à un moment précis.

Nous pouvons empêcher cela en utilisant l'approche du sommeil pour fournir un petit retard à notre logiciel. Pour ce faire, nous devons importer la fonction de sommeil du module temporel pour ajouter une brève pause entre l'exécution des deux threads. À l'exception de l'ajout de la fonction de sommeil, le code est pratiquement identique aux exemples d'avant.

Remarquez les modules, le filet et le sommeil nécessaires. Ces modules sont importés en premier. La fonction de sommeil est ensuite exécutée en deux classes qui sont construites plus tard. Afin d'imprimer la phrase un certain nombre de fois dans notre cas, trois nous avons utilisé la boucle pour les deux classes. Afin d'exécuter l'application, nous avons invoqué la méthode start () après implémentation de l'approche de threading. Les dernières lignes de code du programme le démontrent.

à partir de l'importation de filetage *
à partir de temps pour sommeil
classe Python_demo (thread):
def run (self):
pour I à portée (3):
print ("Demo Python")
sommeil (1)
classe Python_lesson (thread):
def run (self):
pour I à portée (3):
imprimer ("leçon python")
sommeil (1)
first_obj = python_demo ()
second_obj = python_lesson ()
first_obj.commencer()
sommeil (0.3)
second_obj.commencer()

Le résultat démontre maintenant que les fils s'exécutent simultanément.

Exemple 4

Le module de filetage de Python est utilisé pour construire des threads dans l'extrait de code suivant. Le thread principal s'exécute dans le code, et les mots «Ceci est le thread principal» sont imprimés. Le premier thread et le deuxième thread sont deux fils nouvellement établis et en cours d'exécution. Il y a une transition de contexte, et le premier fil commence à fonctionner.

Le premier fil se rend dormir après les quatre premières itérations, tandis que le deuxième fil commence à fonctionner et se termine juste à temps pour l'interrupteur de contexte suivant.

Le CPU est maintenant sous le contrôle du thread principal, qui écrit à nouveau «le fil principal!"

Le deuxième thread reprend son exécution après un autre commutateur de contexte et termine. Le thread principal ne peut plus exécuter plus d'instructions; Par conséquent, le programme se termine.

Importer du thread comme TD
Importer du temps comme t
def print_welcome ():
pour I à portée (5):
Si i == 4:
t.sommeil (2)
imprimer ("bienvenue")
def print_integers (n):
pour i à portée (n + 1):
Imprimer (i)
Imprimer ("Ceci est le fil principal.")
first_thread = td.Thread (cible = print_welcome, args = ())
second_thread = TD.Thread (cible = print_integers, args = (10,))
first_thread.commencer()
second_thread.commencer()
Imprimer ("Fil principal à nouveau!")

Vous pouvez voir la sortie dans cette section, où le thread principal s'exécute en premier, et le message est répété au besoin. Après l'exécution du deuxième thread, qui affichait les nombres, le logiciel est retourné au premier thread et a effectué la fonction qui montre le mot «Bienvenue."

Conclusion

Le sujet de cet article était Python Multithreading. En basculant rapidement entre les threads à l'aide d'un CPU, le multithreading est une technique de threading utilisée dans la programmation Python pour exécuter de nombreux threads simultanément. De plus, il permet le partage de son espace de données avec les threads primaires à l'intérieur d'un processus, qui communiquent et partagent des informations plus facilement que des processus séparés. L'objectif du multithreading est de réaliser de nombreux processus simultanément.