ThreadpoolExecutor Python

ThreadPoolExecutor est une classe Python trouvée dans son package nommé «Concurrent.futurs ". Disons que nous devions faire beaucoup de fils dans nos travaux très parallélisés. C'est le plus coûteux, car il peut y avoir plusieurs problèmes d'efficacité en raison de l'absence de processus. Une grande préoccupation pourrait être que le débit devient contraint. Vous pouvez surmonter ce problème en construisant un pool de fils. Un pool de threads est une collection de processus préinstantiés ou inactifs qui attendent de se voir attribuer un travail. Chaque fois qu'un ensemble important d'activités doit être terminé, l'établissement d'un pool de threads est généralement recommandé de développer de nouveaux processus pour chaque emploi. Une piscine de fil peut effectuer les tâches suivantes:

• Une fois qu'un processus à l'intérieur d'un pool de thread a terminé son traitement, il pourrait être utilisé à nouveau.
• Lorsqu'un fil est terminé, un nouveau fil est formé pour prendre sa place.

Le simultanément.Le package à terme est une partie de la bibliothèque régulière Python. Dans Python 3.2, ce package a été créé pour donner aux programmeurs une interface élevée pour lancer des processus simultanés. C'est un niveau intermédiaire construit au sommet du multitâche de Python ainsi que des packages multiprocesseurs qui vous permet d'effectuer des tâches en utilisant un pool de fils ou de procédures. Dans cet article, nous allons jeter un œil à la classe d'exécuteur de threads Pool et à ses fonctions.

Exemple 01:

Jetons un coup d'œil à la classe d'exécuteur du pool de threads dans notre code Python. Premièrement, nous avons utilisé le «.Futures "Package utilisant le mot clé" From "dans la première ligne pour importer la classe" ThreadPoolExecutor "dans le code. Après cela, nous avons initialisé une liste de 4 numéros. La première fonction est une fonction définie par l'utilisateur nommé «Square» et il calculera un carré d'une valeur réalisée dans ses arguments. L'autre méthode est la fonction du constructeur I.e., Méthode main () à mesure que l'exécution commence à partir de i. Ainsi, la fonction définie par l'utilisateur «carré» est définie à l'aide du mot clé «DEF» et prend la valeur de l'argument pour calculer son carré.

Les supports «» sont utilisés pour prendre la valeur numérique d'une variable «z» au lieu de prendre «z» comme une chaîne ici. Le caractère «F» avant l'instruction Text et Calcul montre que les valeurs seront prises en tant que flotteurs et leur carré sera calculé. L'instruction d'impression utilise ce format pour obtenir un carré et l'imprimer dans le shell de sortie Spyder3. Maintenant, voici le constructeur de fonction Main (). Le constructeur initialise une liste vide nommée «Val». Il est temps d'utiliser la classe ThreadpoolExecutor pour faire une piscine de 5 fils à utiliser de manière asynchrone.

Pour cela, utilisez l'instruction «avec» avec le nom «ThreadpoolExecutor» prenant un argument «Max_Workers» avec la valeur 5. Vous pouvez le voir comme une boucle prenant 1 valeur à chaque fois. La fonction de soumission de la classe threadpoolExecutor est utilisée pour exécuter une fonction I.e., «Square» et donne un carré d'un nombre qui lui est passé. Il prend le numéro 1 comme valeur de départ à la méthode carrée et après cela, il prendra les valeurs de la liste «L». La fonction «Map» est utilisée ici pour traduire rapidement la fonction et itérable collectivement et soulève une erreur dans le «simultanément.Futures »Package. L'exception sera stockée à la variable «Val» et l'instruction d'impression sera utilisée pour afficher cette exception utilisée dans la boucle «For» sur l'écran de sortie.

de simultanément.Importer à terme ThreadPoolExecutor
l = [2,3,4,5]
Def Square (Z):
print (f'square de z: z * z ')
Si __Name__ == '__MAIN__':
val = []
avec ThreadPoolExecutor (max_workers = 5) comme exe:
exe.soumettre (carré, 1)
val = exe.Carte (carré, L)
Pour Res dans Val:
imprimer (res)

Le pool de 5 threads a été créé pour calculer un carré de 5 valeurs à partir de 1 à 5 comme affiché dans la sortie.

Exemple 02:

Voici le dernier exemple de l'utilisation de la classe ThreadPoolExecutor dans Python Code. Nous avons donc commencé ces nouveaux exemples avec l'importation d'une classe en utilisant son package «Concurrent.futurs ". Ensuite, initialisez une variable «somme» avec 0 valeur. La fonction définie par l'utilisateur nommé «Process» est déclarée prendre un argument «n» dedans. Cette fonction imprime les numéros de thread via l'instruction d'impression. Le numéro de thread est résumé avec le numéro 5 ajouté à la variable «SUM». Cette somme calculée pour chaque thread sera affichée sur la sortie en utilisant l'instruction d'impression. La définition de la méthode principale a été lancée ici. Il utilise le threadpoolExecutor pour la création d'un pool de 3 fils. La fonction «processus» a été appelée 3 fois en utilisant la fonction «soumettre» pour 3 valeurs différentes. Après que tous les threads de la méthode de processus soient exécutés, il affichera le message d'achèvement. La déclaration de fonction principale () est utilisée après cela.

de simultanément.Importer à terme ThreadPoolExecutor
Sum = 0
Processus DEF (n):
print ("Traitement du thread: ".format (n))
Sum = n + 5
print ("somme de et 5 est:".format (n), somme)
def main ():
Imprimer ("Démarrer ThreadpoolExecutor")
avec ThreadPoolExecutor (max_workers = 3) comme ex:
val = ex.soumettre (processus, (2))
val = ex.soumettre (processus, (4))
val = ex.soumettre (processus, (5))
imprimer ("tous les threads sont complètement traités")
Si __Name__ == '__MAIN__':
principal()

L'exécution montre que le pool est démarré et chaque numéro de thread avec sa somme avec le numéro 5 s'affiche.

Conclusion:

Nous avons couvert et discuté de la classe ThreadpoolExecutor et toutes les fonctions éventuellement utilisées dans nos exemples. Nous devons le rendre aussi sans prétention que pour nos utilisateurs. Nous avons examiné une carte et soumettre également une fonction. Nous attendons la meilleure réponse.