Exemple de multiprocessement Python

Python est un langage de programmation qui est bénéfique pour développer des sites Web et des applications. Aussi, impliqué dans la visualisation et l'analyse des données. C'est comparativement un langage facile et est souvent utilisé par même des non-programmeurs. Cet article fait référence à l'utilisation du multiprocessement dans Python.

Multiprocessement

Le multitraitement traite du potentiel d'un système qui prend en charge plus d'un processeur à la fois. Toutes les applications en multiprocessement sont démolies en petits modèles, et chacun de ces modèles est auto-dépendant en travail. Dans ce type de processus, deux processus ou plus sont utilisés. Considérons simplement qu'un ordinateur s'exécute avec l'utilisation d'un seul processeur. Si nous attribuons plusieurs processeurs à la fois, il piradera chaque passage à chaque tâche à une autre tâche après un bref temps pour maintenir tous les processus en cours d'exécution. En d'autres termes, s'il y a plus de tâches à faire, plus difficile, ce sera de les maintenir sur la trace de l'achèvement. Tandis que l'allocation de chaque tâche égale le temps est également un grand défi. Dans cette condition, nous devons survenir le concept de multiprocessement. Un système de multiprocessement peut permettre.

• Multiprocesseur: Un ordinateur qui utilise plus d'un processeur central.
• Processeur multi-fond: Un seul composant qui utilise deux ou plusieurs unités de traitement.

Multiprocessement en python

En utilisant le concept de multiprocessement, l'unité de traitement centrale peut facilement exécuter plusieurs tâches en une seule fois. Python utilise le module de multiprocessement pour introduire des codes parallèles. Pour implémenter le multiprocessement, vous devez d'abord connaître le nombre de cœurs dans votre système. Nous avons utilisé un seul morceau de code ici pour connaître les processeurs travaillant à la fois.

Pour Python, vous pouvez utiliser n'importe quel autre outil pour accomplir les codes. Nous avons utilisé l'outil Spyder à cet effet qui exécutera sûrement les codes de langue Python.

Importer le multiprocessement

Print ("Nombre de CPU:", Multiprocessement.cpu_count ())

Premièrement, nous devons importer le multiprocessement «PG» du package qui permettra le travail. Pour chaque PC, la sortie peut varier. Pour moi, le nombre de cœurs est 4.

Exemple 1:

À l'aide d'un module de multiprocessement, nous calculerons les fonctions cube et carrée.

Comprenons le code mentionné ci-dessus. Nous avons créé un processus, puis nous avons créé un objet pour traiter la classe.

P1 = multiprocessement.processus (print (print_cube (5,)))
P2 = multiprocessement.processus (print (print_square (2,)))

P1 et P2 sont les objets des processus. Ces processus contiennent l'appel fonctionnel ayant une fonction d'impression qui appellera directement la fonction avec les arguments comme paramètre. Print_cube et print_square.

Nous utilisons des méthodes de démarrage pour démarrer le processus.

P1.commencer()
P2.commencer()

L'une des fonctions utilisées est décrite comme.

def print_square (num):
print ("carré: ".format (num * num))

La fonction carrée calculera le carré en multipliant le numéro donné utilisé dans l'appel de fonction. La fonction prend le nombre dans la variable «num».

Lorsque nous exécutons le code, la sortie affichera les valeurs résultantes des deux fonctions.

Exemple 2:

À l'aide de structures de données, vous devez être familiarisé avec l'utilisation de piles et de files d'attente dans le langage de programmation. À partir du module de multiprocessement, nous importons une classe de file d'attente ici qui est la structure de données FIFO (First in First Out). Il y aura deux processus qui fonctionneront alternativement. Nous utilisons deux fonctions ici. La fonction put () est utilisée ici pour insérer des données dans la file d'attente. Alors que nous utilisons GET () pour récupérer les articles de la file d'attente. Vous trouverez ci-dessous le code qui illustre le fonctionnement du multiprocessement dans la file d'attente. La première étape consiste à introduire des files d'attente.

De la file d'attente d'importation multiprocesse

Après l'importation du module, introduisez les noms des voitures dans la variable du tableau. Nous utiliserons une boucle pour insérer les valeurs à l'intérieur de la file d'attente, et le put () le fera ainsi. Une variable «CNT» est utilisée pour compter le nombre de voitures utilisées. Initialiser l'objet de file d'attente via l'instruction.

File d'attente = file d'attente ()

Ensuite, une boucle est utilisée pour ajouter des valeurs; Cela utilisera un mot-clé «file d'attente» pour utiliser la fonction put () pour discuter comme le nom de la voiture à insérer. La fonction «CNT» sera incrémentée après chaque insertion.

Pour la voiture dans les voitures:

File d'attente.mettre (voiture)
Cnt + = 1

De même, pour put (), une boucle de temps est utilisée jusqu'à ce que toute la file d'attente ne soit pas vide.

Bien qu'il ne soit pas de file d'attente.vide():

Imprimer ('Article No:', CNT, ", file d'attente.obtenir())
Cnt + = 1

La sortie montre les deux fonctions fonctionnant indépendamment. Une fois qu'une fonction a terminé ses travaux, l'autre processus est utilisé.

Exemple 3:

Cet exemple contient deux processus. Dans chaque processus, «PID» est obtenu via la fonction get (). Nous avons utilisé deux modules. L'un est le multiprocessement, et l'autre est un système d'exploitation.

Chaque processus est alloué un ID différent.

Def Process ():

Print («ID du processus Running Worker1: ».format (OS.getPid ()))

Le message est concaténé avec l'appel de fonction pour recevoir l'ID de processus. Dans le programme principal, l'ID de processus principal est récupéré en utilisant la même approche via Get (). Puis les processus sont créés par multiprocessement. Chaque processus est accessible via ses objets respectifs. je.e., Pour le processus 1, l'objet est P1.

P1 = multiprocessement.Processus (cible = process1)

La cible est la fonction qui doit être exécutée par le processus. Au fur et à mesure que les processus sont créés, alors ils doivent commencer. L'état de chaque processus est affiché; Pour cela, nous devons surveiller l'achèvement du processus. Cela aura besoin de temps pour attendre. Nous utiliserons une fonction qui attendra l'exécution complète du processus.

P1.rejoindre()

Lorsque cette fonction de jointure obtient le signal, il imprime l'instruction que l'exécution est terminée. Un drapeau booléen déterminera que le processus est vivant ou non; Si oui, alors c'est vrai, sinon c'est faux.

Print («Le processus P1 est vivant: ».format (P1.est vivant()))

Exécutez maintenant le programme et prenez la sortie. Vous pouvez voir que l'identifiant principal est affiché puis l'ID de processus de chaque processus. Une fois l'exécution terminée, l'état est affiché pour les deux processus, c'est-à-dire «faux».

Exemple 4:

Dans cet exemple, vous verrez le fonctionnement du temps multiprocesseur et d'importation, pool, cpu_count. Pool est utilisé pour exécuter des processus avec plusieurs entrées et distribuer ces données d'entrée entre les processus. Une fonction carrée calculera le carré de la valeur d'entrée. En utilisant le module temporel du package, nous utiliserons la fonction de sommeil.

Temps.sommeil (3)

Cette fonction a une expansion de temps de 3 secondes. Cela signifie que la valeur de cette fonction sera affichée après cette heure spécifique. Dans le programme principal, nous commençons la minuterie, puis les valeurs factices de chaque 4 cœurs sont allouées.

Avec piscine () comme piscine:

Res = pool.Carte (carré, valeurs)
Imprimer (res)

La fonction de pool consiste à donner des valeurs et à appeler la fonction en même temps. Ensuite, nous devons arrêter la minuterie. Cette fonction temporaire comptera les secondes utilisées pour cette fonction, connue sous le nom de temps écoulé; Il est obtenu en soustrayant la valeur de début du temps de la valeur finale.

Exécutez maintenant le programme. La première ligne est affichée, puis il faut 3 secondes. Après cela, un autre résultat est montré.

Conclusion

«Exemple de multiprocessement Python» est une brève introduction au phénomène de multiprocessement. Chaque exemple expliqué ici importe différents packages à partir du module de multiprocessement. Cette manipulation des processus parallèles les unes aux autres est accomplie à travers le nombre de processeurs. Plus le nombre de CPU plus importants sera la possibilité d'un bon multiprocessement.