Qu'est-ce que Mutithreading en Python et comment y parvenir?

Le temps est le facteur le plus critique de la vie. En raison de son importance, le monde de la programmation fournit diverses astuces et techniques qui vous aident considérablement à réduire la consommation de temps, augmentant ainsi les performances. L'une de ces approches est le multithreading en Python, qui est l'un des concepts les plus importants couverts par .

Voici un bref résumé de toutes les majors couvertes dans cet article:

quels sont les événements en javascript

Quel est multitâche en Python?
Qu'est-ce qu'un fil?
Qu'est-ce que le multithreading en python?
Quand utiliser le multithreading en Python?
Comment réaliser le multithreading en Python?
Comment créer des threads en Python?

• sans créer de classe
• en étendant la classe de thread
• sans étendre la classe de thread

Avantages de l'utilisation du multithreading en Python

Pour commencer, essayons d'abord de comprendre le multitâche avant de commencer à apprendre le multithreading en Python.

Qu'est-ce que le multitâche en Python?

Le multitâche, en général, est la capacité d'effectuer plusieurs tâches simultanément. En termes techniques, le multitâche fait référence à la capacité d'un système d'exploitation à effectuer différentes tâches en même temps. Par exemple , vous téléchargez quelque chose sur votre PC, écoutez des chansons et jouez simultanément à un jeu, etc. Toutes ces tâches sont effectuées par le même système d'exploitation et synchronisées. Ce n'est rien d'autre que le multitâche qui vous permet non seulement de gagner du temps, mais également d'augmenter la productivité.

Il existe deux types de multitâche dans un système d'exploitation:

• Basé sur les processus
• Basé sur le fil

Dans cet article, vous découvrirez Basé sur le fil multitâche ou Multithreading .

Qu'est-ce qu'un fil?

Un fil est fondamentalement un indépendant flux d'exécution. Un même processus peut être composé de plusieurs threads. Chaque thread d'un programme exécute une tâche particulière. Par exemple, lorsque vous jouez à un jeu, dites FIFA sur votre PC, le jeu dans son ensemble est un processus unique , mais il se compose de plusieurs threads responsables de la lecture de la musique, de la prise d'entrée de l'utilisateur, de l'exécution de l'adversaire de manière synchrone, etc. Ce sont tous des threads séparés chargés d'exécuter ces différentes tâches dans le même programme.

Chaque processus a un thread qui est toujours en cours d'exécution. Ceci est le fil conducteur. Ce thread principal crée en fait les objets thread enfants. Le thread enfant est également lancé par le thread principal. Je vais vous montrer tous plus loin dans cet article comment vérifier le thread en cours d'exécution.

Donc, avec cela, j'espère que vous avez clairement compris ce qu'est un fil. Voyons maintenant ce qu'est le multithreading en Python.

Quand utiliser le multithreading en Python?

Le multithreading est très utile pour gagner du temps et améliorer les performances, mais il ne peut pas être appliqué partout.
Dans l'exemple FIFA précédent, le thread musical est indépendant du thread qui prend votre entrée et le thread qui prend votre entrée est indépendant du thread qui exécute votre adversaire. Ces threads s'exécutent indépendamment car ils ne sont pas interdépendants.

Par conséquent, le multithreading ne peut être utilisé que lorsque la dépendance entre les threads individuels n'existe pas.

Cet article montre en outre comment vous pouvez réaliser le multithreading en Python.

Comment réaliser le multithreading en Python?

Le multithreading en Python peut être réalisé en important le filetage module.

Avant d'importer ce module, vous devrez l'installer. Pour l'installer sur votre environnement anaconda, exécutez la commande suivante sur votre invite anaconda:

conda installer -c conda-forge tbb

Une fois son installation réussie, vous pouvez utiliser l'une des commandes suivantes pour importer le module de thread:

importer des threads depuis l'importation des threads *

Maintenant que vous avez installé le module de threading, allons de l'avant et faisons du multithreading en Python.

Comment créer des threads en Python?

Les threads en Python peuvent être créés de trois manières:

1. Sans créer de classe
2. En étendant la classe Thread
3. Sans étendre la classe de thread

Sans créer de classe

Le multithreading en Python peut être accompli sans créer également de classe. Voici un exemple pour démontrer la même chose:

Exemple:

from threading import * print (current_thread (). getName ()) def mt (): print ('Child Thread') child = Thread (target = mt) child.start () print ('Nom du thread d'exécution:', current_thread ( ) .getName ())

Production:

MainThread Child Thread Exécution du nom du thread: MainThread

La sortie ci-dessus montre que le premier thread présent est le thread principal. Ce thread principal crée ensuite un thread enfant qui exécute la fonction, puis l'instruction d'impression finale est à nouveau exécutée par le thread principal.

Voyons maintenant comment faire du multithreading en python en étendant la classe Thread.

En étendant la classe Thread:

Lorsqu'une classe enfant est créée en étendant la classe Thread, la classe enfant représente qu'un nouveau thread exécute une tâche. Lors de l'extension de la classe Thread, la classe enfant ne peut remplacer que deux méthodes, à savoir la méthode __init __ () et la méthode run (). Aucune autre méthode ne peut être remplacée que ces deux méthodes.

Voici un exemple de la façon d'étendre la classe Thread pour créer un thread:

Exemple:

import threading import time class mythread (threading.Thread): def run (self): for x in range (7): print ('Hi from child') a = mythread () a.start () a.join () print ('Au revoir de', current_thread (). GetName ())

Production:
Salut de l'enfant
Salut de l'enfant
Salut de l'enfant
Salut de l'enfant
Salut de l'enfant
Salut de l'enfant
Salut de l'enfant
Au revoir de MainThread

L'exemple ci-dessus montre que la classe myclass hérite de la classe Thread et de la classe enfant, c'est-à-dire que myclass remplace la méthode d'exécution. Par défaut, le premier paramètre de toute fonction de classe doit être self qui est le pointeur vers l'objet actuel. La sortie montre que le thread enfant exécute la méthode run () et le thread principal attend que l'exécution de l'enfant se termine. Cela est dû à la fonction join (), qui oblige le thread principal à attendre la fin de l'enfant.

Cette méthode de création de threads est la méthode la plus préférée car c'est la méthode standard. Mais si vous souhaitez créer des threads sans hériter ou étendre la classe Thread, vous pouvez le faire de la manière suivante.

Sans extension de la classe de thread

Pour créer un thread sans étendre la classe Thread, vous pouvez procéder comme suit:
Exemple:

from threading import * class ex: def myfunc (self): #self nécessaire comme premier paramètre dans une classe func for x in range (7): print ('Child') myobj = ex () thread1 = Thread (target = myobj. myfunc) thread1.start () thread1.join () print ('done')

Production:

Enfant
Enfant
Enfant
Enfant
Enfant
Enfant
Enfant
terminé

Avantages de l'utilisation du filetage

Le multithreading présente de nombreux avantages, dont certains sont les suivants:

• Meilleure utilisation des ressources
• Simplifie le code
• Permet l'occurrence simultanée et parallèle de diverses tâches
• Réduit la consommation de temps ou le temps de réponse, augmentant ainsi les performances.

Voici un exemple pour vérifier combien de temps il faut à un code pour s'exécuter avec et sans multithreading en python:

 Exemple: 

import time def sqr (n): for x in n: time.sleep (1) x% 2 def cube (n): for x in n: time.sleep (1) x% 3 n = [1,2,3 , 4,5,6,7,8] s = time.time () sqr (n) cube (n) e = time.time () print (es)

Production:

16,042309284210205

Ce qui précède est le temps de sortie nécessaire pour exécuter le programme sans utiliser de threads. Maintenant, utilisons les threads et voyons ce qui arrive au même programme:

Exemple:

import threading from threading import * import time def sqr (n): for x in n: time.sleep (1) print ('Reste après division par 2', x% 2) def cube (n): for x in n: time.sleep (1) print ('Reste après division par 3', x% 3) n = [1,2,3,4,5,6,7,8] start = time.time () t1 = Thread ( target = sqr, args = (n,)) t2 = Thread (cible = cube, args = (n,)) t1.start () time.sleep (1) t2.start () t1.join () t2.join () end = time.time () print (fin-début)

La sortie ci-dessus montre clairement que le temps nécessaire à l'utilisation des threads est bien inférieur au temps nécessaire pour que le même programme s'exécute sans utiliser de threads.

J'espère que vous êtes clair avec les concepts abordés dans cet article lié au multithreading en Python. Assurez-vous de vous entraîner autant que possible car c'est l'un des concepts les plus importants utilisés en programmation.

Vous avez une question pour nous? Veuillez le mentionner dans la section commentaires de ce blog «Multithreading en Python» et nous volonté vous recontactera dans les plus brefs délais.

Pour obtenir des connaissances approfondies sur Python ainsi que sur ses différentes applications, vous pouvez vous inscrire en direct avec une assistance 24/7 et un accès à vie.