(Tutoriel) Definitive Guide :Threading in Python

Si vous venez de commencer en Python et que vous souhaitez en savoir plus, suivez le cours Introduction à la science des données en Python de DataCamp.

Introduction

Threading permet d’avoir les différentes parties de votre processus de s’exécuter simultanément (Source: RealPython). Ces différentes parties sont généralement individuelles et ont une unité d’exécution distincte appartenant au même processus., Le processus n’est rien d’autre qu’un programme en cours d’exécution qui a des unités individuelles qui peuvent être exécutées simultanément. Par exemple, un navigateur web pourrait être un processus, une application exécutant plusieurs caméras simultanément pourrait être un processus; un jeu vidéo est un autre exemple de processus.

à l’intérieur d’un processus vient le concept de threading multiple ou communément appelé multi-threading, où plusieurs threads travaillent ensemble pour atteindre un objectif commun. Le plus important avantage de l’utilisation des threads, c’est qu’il vous permet d’exécuter le programme en parallèle.,

comprenons le concept de threading à l’aide d’un exemple. Imaginez que vous avez une application qui compte le nombre de voitures entrant et sortant du parking du centre commercial. Votre appareil dispose de diverses caméras qui surveillent l’entrée et la sortie se connectant à un appareil central. Chaque caméra aura un algorithme pour surveiller le flux de voitures, qui appartiendront au même processus ou programme. Cependant, chaque appareil, ainsi que l’algorithme il est exécuté sur, pourrait faire partie d’un thread séparé., Non seulement cela, mais même les images lues à partir de la caméra et l’algorithme de prédiction sur les images pourraient également être deux threads distincts.

un autre exemple pourrait être un jeu vidéo dans lequel le processus doit exécuter les tâches en parallèle comme les graphiques, l’interaction de l’utilisateur et la mise en réseau (tout en jouant à des jeux multijoueurs) car il doit être réactif à tout moment. Et pour ce faire, il doit utiliser le concept de multi-threading, où chaque thread serait responsable de l’exécution de chaque indépendants et des tâches individuelles.,

Un thread a son flux d’exécution, ce qui signifie que le processus aura plusieurs choses à la fois.

Il est important de noter que chaque processus a au moins un thread, appelémain thread. Si votre programme n’a pas de thread défini, il aura au moins le thread principal, c’est-à-dire le processus lui-même.

Si vous regardez le diagramme ci-dessus, il y a un processus qui se compose du thread principal composé de variables globales et de trois threads différents t1, t2 et t3. Chaque thread a ses variables locales et son flux d’exécution du code., Les threads partagent généralement les ressources du processus, comme les ressources disponibles pour le thread principal va également être partagés entre les trois threads t1, t2, et t3. Tous les threads auront accès aux variables globales tout en ayant leurs propres variables locales.,

Il existe différents types de fils:

thread du Noyau
l’Utilisateur thread
Combinaison de noyau et utilisateur thread

Maintenant regardons quelques-uns des avantages d’avoir threading dans votre programme:

le Multi-threading permet à la programme pour accélérer l’exécution à condition qu’elle dispose de plusieurs Processeurs.
Il vous permet également d’effectuer d’autres tâches pendant les opérations d’e/S sont effectuées avec l’aide de plusieurs threads ou même thread principal avec un seul thread., Par exemple, la vitesse à laquelle les images de la caméra sont lues et déduites par l’algorithme sera gérée par différents threads. Par conséquent, l’algorithme n’aura pas à attendre que la trame soit entrée, et la partie de lecture de trame n’aura pas à attendre la fin de l’exécution de l’algorithme pour pouvoir lire la trame suivante.

les Threads du même processus peuvent partager de la mémoire et des ressources du thread principal.,

défis du Threading:

rappelez-vous que Python fonctionne sur la base de L’implémentation CPython, qui limite l’exécution d’un seul thread à la fois, par conséquent; le threading peut ne pas accélérer toutes les tâches. Et la raison essentielle derrière cela est Global Interpreter Lock (GIL).

Si vous souhaitez en savoir plus sur GIL, alors n’hésitez pas à consulter ce tutoriel.
Si vous cherchez à accélérer la tâche intensive du processeur, le threading n’est peut-être pas la meilleure solution pour vous. Dans de tels cas, le multitraitement est considéré comme utile.,
pour exécuter un programme composé de différents threads, il doit basculer rapidement entre les threads; par conséquent, la planification doit être prise en charge dans les programmes où vous avez beaucoup de threads.
Le partage de ressources peut également être un problème car tous les threads partagent les mêmes ressources et la même mémoire des variables globales. Par conséquent, les opérations effectuées dans un thread peuvent provoquer une erreur de mémoire pour un autre thread, ou l’autre thread peut ne pas obtenir la mémoire pour effectuer sa tâche.,

Filetage en Python

En Python, le filetage module est un module intégré qui est connu comme threading et peuvent être directement importés.
Puisque presque tout en Python est représenté par un objet, le filetage est également un objet en Python. Un thread est capable de
- contenir des données,
- stockées dans des structures de données telles que des dictionnaires, des listes, des ensembles, etc.
- Peut être passé en paramètre à une fonction.
Un thread peut également être exécuté en tant que processus.,
Un thread en Python peut avoir différents états de la forme:
- Attendre
- Verrouillé.

voyons maintenant comment vous pouvez implémenter le threading en Python.

module Thread dans Python3

notez que Python3 est rétrocompatible avec le modulethread, qui existe dans Python2.7. Dans Python3, il peut être importé en tant que module _thread. Prenons donc un exemple et comprenons le module _thread.,

import _thread #thread module importedimport time #time module

définissons une fonction appeléethread_delay, qui prendra deux paramètres en entrée, à savoir le nom du thread et le délai. A l’intérieur de cette fonction, vous allez:

définir un compteur avec zéro,
ensuite, vous allez faire une boucle avec une boucle while qui s’exécutera trois fois,
à l’intérieur de la boucle while, vous mettrez time.sleep() pour ajouter du retard, ce délai sera utile pour comprendre, Ce délai sera en secondes,
ensuite, vous incrémenterez votre compteur de 1,
pour voir si l’exécution de votre thread se déroule bien, vous imprimerez le nom du thread et l’heure à laquelle le thread est exécuté.

def thread_delay(thread_name, delay): count = 0 while count < 3: time.sleep(delay) count += 1 print(thread_name, '-------->', time.time())

Maintenant, pour ajouter la fonctionnalité de thread sur la fonction ci-dessus ou à exécuter la fonction ci-dessus dans le fil, vous devez utiliser la balise start_new_thread méthode, qui est à l’intérieur de la balise _thread module.

voyons la docstring de la méthodestart_new_thread.,

?_thread.start_new_thread

Laissez-passer dans la fonction thread_delay sans les parenthèses et les deux arguments, c’est à dire, le nom du thread et le retard (pour visualiser l’exécution du thread car il est très rapide).

_thread.start_new_thread(thread_delay, ('t1', 1))_thread.start_new_thread(thread_delay, ('t2', 3))

à Partir du dessus de la sortie, vous pouvez voir que le thread t1 commence à s’exécuter en premier., Pendant ce temps, thread t2 attend car il y a un délai de 3 secondes, et dès que ce délai est terminé, thread t2 est exécutée, et aussi, le délai de thread t1 est à seulement 1 seconde.

nous allons maintenant modifier le délai de t2 à 5 secondes, ce qui permettrait de démarrer t2 après t1 aurait fini de s’exécuter depuis t1 prendra seulement 3 secondes pour terminer son exécution.,

_thread.start_new_thread(thread_delay, ('t1', 1))_thread.start_new_thread(thread_delay, ('t2', 5))

implémentation du threading à l’aide du module de Threading

utilisons le même exemple que vous avez utilisé ci-dessus, mais cette fois vous utiliserez le modulethreading au lieu du module_thread.

import threadingimport time

def thread_delay(thread_name, delay): count = 0 while count < 3: time.sleep(delay) count += 1 print(thread_name, '-------->', time.time())

à l’Intérieur de la balise threading module est un Thread de classe, qui est un esprit similaire à la balise start_new_thread fonction de l ‘ _thread module.,

regardons la docstring de la classeThread, qui prend en compte plusieurs paramètres tels que group, target (comme une fonction), args, etc.

?threading.Thread

Dans le constructeur de la classe Thread, vous passerez dans la fonction cible thread_delay et les arguments de cette fonction.,

t1 = threading.Thread(target=thread_delay, args=('t1', 1))t2 = threading.Thread(target=thread_delay, args=('t2', 3))

Dans le module threading, afin d’exécuter ou exécuter le thread, vous devez utiliser la balise start() méthode, qui, tout simplement, responsable de l’exécution du thread.

?t1.start

t1.start()t2.start()

Vous pourrez également utiliser la balise join méthode, ce qui signifie que d’attendre jusqu’à ce que tous les threads d’exécution est terminée., Ainsi, quel que soit le code que vous avez écrit après la méthode join ne sera exécuté qu’une fois ces threads terminés.

?t1.join

t1.start()t2.start()t1.join()t2.join()print("Thread execution is complete!")

Maintenant, nous allons calculer le volume du cube et le carré à l’aide du filetage concept, qui est assez simple.

def volume_cube(a): print ("Volume of Cube:", a*a*a)

def volume_square(a): print ("Volume of Square:", a*a)

t1 = threading.Thread(target=volume_cube, args=(2))t2 = threading.Thread(target=volume_square, args=(3))

t1.start()t2.start()t1.join()t2.join()print("Thread execution is complete!")

Attendez, quoi? Dès que vous avez exécuté la méthode start, cela a entraîné une erreur., En effet, le paramètre args attend un tuple, et puisque le volume_cube Et volume_square n’attend qu’un seul paramètre, vous devez donc mettre une virgule dans le args paramètre après avoir spécifié le premier argument des fonctions.

t1 = threading.Thread(target=volume_cube, args=(2,))t2 = threading.Thread(target=volume_square, args=(3,))

t1.start()t2.start()t1.join()t2.join()print("Thread execution is complete!")

Volume of Cube: 8Volume of Square: 9Thread execution is complete!

nous allons maintenant apprendre à utiliser les enfiler comme une sous-classe.,

enfiler comme une sous-classe

Dans cette section, vous allez apprendre comment créer une sous-classe de la classe thread, qui est disponible à l’intérieur du module threading, puis créer de thread instances de t1 et t2 de classe.

vous utiliseriez la même fonctionthread_delay ici aussi.

Maintenant, nous allons comprendre le code ci-dessus, étape par étape:

Vous avez défini une classe DataCampThread, et dans la classe argument, vous avez passé dans le threading.Thread de classe., La raison pour laquelle vous faites cela est que vous souhaitez créer une sous-classe à partir du module de threading. Cela vous permet d’utiliser toutes les méthodes disponibles dans la classe threading.Thread similaire au concept d’héritage.
ensuite, vous avez défini la méthode init de la classe DataCampThread et passé la fonction avec le délai. L’init est un constructeur similaire aux paramètres que vous avez passés à la classe threading.Thread, ici vous passeriez à la classe DataCampThread.,
Ensuite, l’initialisation de la méthode init de l’enroulement principal.Classe de Thread, puis assimiler le nom et le retard.
Ensuite, vous définissez la balise run méthode, rappelons ici vous avez défini le start méthode, qui, en gros, en dessous de la hotte appelle la run méthode. Puisque vous avez hérité de la classe main, vous êtes autorisé à apporter des modifications à la méthode run., Par conséquent, lorsque vous appelez la méthode start, toutes les modifications que vous ferez dans la méthode run seront reflétées maintenant.

Conclusion

Félicitations pour finir le tutoriel.

Ce tutoriel était une introduction de base au threading en python. Cependant, le threading est un sujet très vaste et vital, et certains concepts pourraient avoir été laissés inexplorés. N’hésitez pas à regarder plus de méthodes de threading comme le nombre actif, le thread actuel, etc.

Si vous souhaitez en savoir plus, consultez également le parallélisme basé sur les threads de Python.,