Multiprocessing en Python

Dans cet article, nous allons apprendre comment nous pouvons réaliser du multiprocessus en utilisant Python. Nous discutons également

ses concepts avancés.

Qu'est-ce que le multiprocessus ?

La multiplication des processus est la capacité du système à exécuter un ou plusieurs processus en parallèle. En termes simples

les mots, le multiprocesseur utilise deux ou plusieursCPUdans le système informatique unique. Ceci
la méthode est également capable d'allouer les tâches entre plus d'un processus.

Les unités de traitement partagent la mémoire principale et les périphériques pour exécuter des programmes simultanément.

L'application de multiprocessus se divise en parties plus petites et s'exécute de manière indépendante. Chaque processus est

allocated to the processor by the operating system.

Pythonfournit le package intégré appelé multiprocessing qui prend en charge l'échange de processus.
Avant de travailler avec le multiprocessus, nous devons nous familiariser avec l'objet de processus.

Pourquoi le multiprocédés ?

Le multiprocesseur est essentiel pour exécuter les multiples tâches au sein du système informatique. Supposons

un ordinateur sans multiprocesseur ni processeur unique. Nous attribuons divers processus à cela
système en même temps.

Il devra alors interrompre la tâche précédente et passer à une autre pour que tous les processus se poursuivent.
C'est aussi simple qu'un chef qui travaille seul dans la cuisine. Il doit accomplir plusieurs tâches pour cuisiner.

comme couper, nettoyer, cuisiner, pétrir la pâte, cuire, etc.

Par conséquent, le traitement multiprogramme est essentiel pour effectuer plusieurs tâches en même temps sans

interruption. Cela rend également facile de suivre toutes les tâches. C'est pourquoi le concept de multiprocessus

est de surgir.

La multiprocession peut être représentée comme un ordinateur avec plus d'un processeur central.
 Un processeur multi-core fait référence à un composant informatique unique avec deux cœurs ou plus.

unités indépendantes.

Dans le multiprocesseur, le CPU peut attribuer plusieurs tâches à chaque tâche ayant son propre processeur.

Multiprocessing en Python

Python fournit le module multiprocessing pour effectuer plusieurs tâches au sein d'un même système.
Il offre une API conviviale et intuitive pour travailler avec le multiprocessing.

Comprenons l'exemple simple du traitement multiple.

Exemple -

1. depuis multiprocessing importer Process

2. def disp():
3. print ('Bonjour !! Bienvenue au tutoriel Python')
4. si __nom__ == '__principal__':

5. p=Process(target=disp)
6. [Link]()
7. [Link]()

Output:

Bonjour !! Bienvenue dans le Tutoriel Python

Explication :

In the above code, we have imported the Process class then create the Process object within
la fonction thedisp(). Ensuite, nous avons commencé le processus en utilisant la méthode thestart() et l'avons terminé

traitement avec la méthode join(). Nous pouvons également passer les arguments dans la fonction déclarée en utilisant

les arguments mots clés

Comprenons l'exemple suivant du multitraitement avec des arguments.

 Exemple - 2

1. # Exemple de multiprocessus en Python

2. # importation du module multiprocessing
3.
4. importer multiprocessing
5. def cube(n):
6. Cette fonction affichera le cube du nombre donné
7. print("Le cube est : {}").format(n * n * n)
8.
9. def carré(n):
10. # Cette fonction affichera le carré du nombre donné
11. print("Le carré est : {}".format(n * n))
12.
13. if__name__== "__main__":
14. création de deux processus
15.process1=[Link](target=square,args=(5, ))
16.process2=[Link](target=cube,args=(5, ))
17.
18. # Ici nous commençons le processus 1
19. process1.démarrer()
20. # Ici, nous commençons le processus 2
21. [Link]()
22.
23. # La méthode join() est utilisée pour attendre que le processus 1 se termine
24. [Link]()
25. # Il est utilisé pour attendre que le processus 1 soit terminé

26. [Link]()
27.
28. # Imprimer si les deux processus sont terminés
29. print("Les deux processus sont terminés")
 Output:

Le cube est : 125

Le carré est : 25
Les deux processus sont terminés

Explication -

Dans l'exemple ci-dessus, nous avons créé les deux fonctions - la fonction thecube() calcule le donné
le cube du nombre, et la fonction square() calcule le carré du nombre donné.

Ensuite, nous avons défini l'objet de processus de la classe Process qui a deux arguments. Le premier
l'argument est une cible qui représente la fonction à exécuter, et le deuxième argument est args
cela représente l'argument à passer dans la fonction.

1.process1=[Link](target=square,args=(5, ))
2.process2=[Link](target=cube,args=(5, ))

Nous avons utilisé la méthode thestart() pour démarrer le processus.

1. process1.démarrer()
2. [Link]()

Comme nous pouvons le voir dans la sortie, cela attend l'achèvement du processus un puis du processus deux. Le dernier

L'instruction est exécutée après que les deux processus soient terminés.

Classes de multiprocessing en Python

Le module de multiprocessage Python fournit de nombreuses classes couramment utilisées pour construire
programme parallèle. Nous allons discuter de ses principales classes - Processus, File et Verrou. Nous avons déjà
nous avons discuté de la classe Process dans l'exemple précédent. Maintenant, nous allons discuter de la Queue et du Lock

classes.

Voyons un exemple simple de récupération du nombre de processeurs actuellement dans le système.

 Exemple -

1. importer le multiprocessus
2. print("Le nombre de CPU actuellement en fonctionnement dans le système : ", multiprocessing.cpu_count())

Output:

Le nombre de CPU actuellement en fonctionnement dans le système : 32

Le nombre de processeurs ci-dessus peut varier pour votre PC. Pour nous, le nombre de cœurs est de 32.

Multiprocessing Python utilisant la classe Queue

Nous savons que la file d'attente est une partie importante de la structure de données. Le multiprocessus Python est précisément

le même que la structure de données de la file d'attente, qui est basée sur le concept de "Premier entré, Premier sorti". File d'attente

gère généralement l'objet Python et joue un rôle essentiel dans le partage des données entre les processus.

Les files d'attente sont passées en tant que paramètre dans la fonction cible du processus pour permettre au processus de consommer.

Les données. La Queue fournit la fonction put() pour insérer les données et la fonction get() pour obtenir des données.

les files d'attente. Comprenons l'exemple suivant.

Exemple -

# Importation de la classe Queue

2.
3. depuis le multiprocessing importer Queue

4.
[Link]= ['Apple', 'Orange', 'Guava', 'Papaya', 'Banana']
[Link]=1
7. # création d'un objet de file d'attente
[Link]=Queue()
9. print('ajout d'éléments à la file :')
10. pour fr dans fruits :
11. print('numéro d'article: ', count, ' ', fr)

12. [Link](fr)
13. count += 1
14.
impression('popping items from the queue :')
[Link]=0
17. tant que la file d'attente n'est pas vide :

18. print('numéro d'article : ', count, ' ', [Link]())

19. compteur += 1

Output:

ajout d'éléments à la file d'attente :

('item no: ', 1, ' ', 'Apple')

('item no: ', 2, ' ', 'Orange')
('item no: ', 3, ' ', 'Guava')
('item no: ', 4, ' ', 'Papaya')
('item no: ', 5, ' ', 'Banana')

retirer des éléments de la file d'attente :

('item no: ', 0, ' ', 'Apple')

('item no: ', 1, ' ', 'Orange')
numero de l'article : 2 Guava
('item no: ', 3, ' ', 'Papaya')
('item no: ', 4, ' ', 'Banana')

Explication -

Dans le code ci-dessus, nous avons importé la classe Queue et initialisé la liste nommée fruits. Ensuite,
nous avons attribué un compteur à 1. La variable compteur comptera le nombre total d'éléments. Ensuite, nous
a créé l'objet de la file d'attente en appelant la méthode Queue(). Cet objet sera utilisé pour effectuer
 opérations dans la File d'attente. Dans la boucle for, nous avons inséré les éléments un par un dans la file d'attente en utilisant

la fonction put() et a augmenté le compteur de 1 à chaque itération de la boucle.

Classe Lock de Multiprocessing en Python

La classe Lock de multiprocessing est utilisée pour acquérir un verrou sur le processus afin que nous puissions le tenir.

autre processus pour exécuter un code similaire jusqu'à ce que le verrou ait été libéré. La classe Lock exécute
principalement deux tâches. La première consiste à acquérir un verrou en utilisant la fonction acquire() et la seconde est de

libérez le verrou en utilisant la fonction therelease().

Exemple de multi-traitement Python

Supposons que nous ayons plusieurs tâches. Donc, nous créons deux files d'attente : la première file d'attente maintiendra le

tâches, et l'autre stockera le journal complet des tâches. La prochaine étape est d'instancier les processus
pour compléter la tâche. Comme discuté précédemment, la classe Queue est déjà synchronisée, donc nous
il n'est pas nécessaire d'acquérir un verrou en utilisant la classe Lock.

Dans l'exemple suivant, nous allons fusionner toutes les classes de multi-traitement. Voyons le
exemple ci-dessous.

Exemple -

1. depuis multiprocessing import Lock, Process, Queue, current_process

2. importer le temps

3. importer la file d'attente

4.
5.
6. def travailÀFaire(tâchesÀEffectuer, tâchesComplètes):
7. tant que vrai :

8. essayer :
9.
10. Le bloc try pour attraper une tâche de la file d'attente.
11. La fonction get_nowait() est utilisée pour
12. lever une exception [Link] si la file d'attente est vide.

13.
14. tâche=tasks_to_perform.get_nowait()
15.
16. except [Link]:
17.
18. pause
19. sinon :
20.
21. # si aucune exception n'a été levée, le bloc else s'exécutera
22. ajouter l'achèvement de la tâche

23.
24.
25. imprimer(tâche)
26. complete_tasks.put(task + ' est terminé par ' + current_process().name)
27. [Link](.5)
28. retourner Vrai
29.
30.
31. def main():
32.total_task=8
33.total_number_of_processes=3
34.tasks_to_perform=Queue()
35.complete_tasks=Queue()
36.number_of_processes= []
37.
38. pour i dans range(total_task):
39. tasks_to_perform.put("Task no " + str(i))
40.
41. # définir le nombre de processus
42. pour w dans la plage(total_number_of_processes) :
43. p=Process(target=jobTodo,args=(tasks_to_perform, complete_tasks))
44. number_of_processes.append(p)
45. [Link]()
46.
47. # processus de finalisation
48. pour p dans le nombre de processus :

49. [Link]()
50.
51. # imprimez la sortie
52. tant que complete_tasks.est_vide():
53. print(complete_tasks.get())
54.
55. retourne Vrai
56.
57.
58. si__nom__== '__principal__':
59. principal()

Output:

Tâche n° 2
Tâche n° 5
Tâche n° 0
Tâche n° 3
Tâche n° 6
Tâche n° 1
Tâche n° 4
Tâche n° 7
Task no 0 is done by Process-1
La tâche n° 1 est effectuée par le Processus-3

La tâche n° 2 est réalisée par le Processus-2

 La tâche n° 3 est effectuée par le Processus-1

La tâche n° 4 est effectuée par le Processus-3

La tâche n° 5 est effectuée par le Processus-2

La tâche n° 6 est réalisée par le Processus-1

La tâche n° 7 est effectuée par le Processus-3

Pool de multiprocessus Python

Le pool de multiprocessing de Python est essentiel pour l'exécution parallèle d'une fonction sur plusieurs entrées.
valeurs. Il est également utilisé pour distribuer les données d'entrée entre les processus (parallélisme des données). Considérer

l'exemple suivant d'un Pool de multiprocessing.

Exemple -

1. depuis multiprocessing importer Pool

2. importer le temps

3.
4.w= (["V", 5], ["X", 2], ["Y", 1], ["Z", 3])
5.
6.
7. def journal_de_travail(données_pour_le_travail):

8. print(" Le nom du processus est %s et le temps d'attente est de %s secondes" % (data_for_work[0], data_for_work[

1]))
9. [Link](int(data_for_work[1]))
10. print(" Process %s Exécuté." % data_for_work[0])
11.
12.
13. def gestionnaire():

14.p=Piscine(2)
15. [Link](work_log, w)
16.
17. si__nom__== '__principal__':
18. gestionnaire()

Output:

Le nom du processus est V, le temps d'attente est de 5 secondes.

Processus V exécuté.
Le nom du processus est X, le temps d'attente est de 2 secondes

Processus X exécuté.
Le nom du processus est Y, le temps d'attente est de 1 seconde

Processus Y exécuté.
Le nom du processus est Z, le temps d'attente est de 3 secondes

Processus Z exécuté.

Comprenons un autre exemple du Pool de multitraitement.

Exemple - 2

1. depuis multiprocessing importer Pool

2. def fun(x):
3. retourner x*x
4.
5. si __nom__== '__principal__':
6. avec Pool(5) comme p :
7. imprimer([Link](fun, [1, 2, 3]))

Output:

[1, 8, 27]

Objets Proxy

Les objets proxy sont appelés objets partagés qui résident dans un processus différent.
un objet est également appelé proxy. Plusieurs objets proxy peuvent avoir un référent similaire. Un proxy
 L'objet se compose de diverses méthodes qui sont utilisées pour invoquer les méthodes correspondantes de son

référent. Voici un exemple d'objets proxy.

Exemple -

1. depuis multiprocessing importer Manager

[Link]=Manager()
3.l=[Link]([i*i pour i in range(10)])
4. imprimer(l)
5. print(repr(l))
6. print(l[4])
7. print(l[2:5])

Output:

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

<ListProxy objet, typeid 'list' à 0x7f063621ea10>
16
[4, 9, 16]

Les objets proxy sont sérialisables, donc nous pouvons les passer entre les processus. Ces objets sont également

utilisé pour le niveau de contrôle sur la synchronisation.

Fonctions couramment utilisées du multiprocessing

Jusqu'à présent, nous avons discuté des concepts de base du multiprocessus en utilisant Python. Le multiprocessus est

un sujet large en soi et essentiel pour effectuer diverses tâches au sein d'un système unique. Nous sommes
définir quelques fonctions essentielles qui sont couramment utilisées pour atteindre le multiprocessus.

Méthode Description

tube() La fonction pipe() renvoie une paire d'objets de connexion.

exécuter() La méthode run() est utilisée pour représenter les activités du processus.

commencer() La méthode start() est utilisée pour démarrer le processus.

rejoindre([délai]) La méthode join() est utilisée pour bloquer le processus jusqu'au processus dont la méthode join() est
appel terminé. Le délai d'attente est un argument optionnel.

is_alive() Il retourne si le processus est actif.

terminer() Comme son nom l'indique, il est utilisé pour terminer le processus. Souvenez-vous toujours -

la méthode terminate() est utilisée sous Linux, pour Windows, nous

utiliser la méthode useTerminateProcess()

tuer() Cette méthode est similaire à terminate() mais utilise le signal SIGKILL sur Unix.

fermer() Cette méthode est utilisée pour fermer l'objet Process et libérer toutes les ressources associées.

avec ça.

qsize() Elle renvoie la taille approximative de la file d'attente.

vide() Si la file d'attente est vide, cela renvoie vrai.

plein() Il retourne vrai si la file d'attente est pleine.

get_attendre() Cette méthode est équivalente à get(False).

obtenir() Cette méthode est utilisée pour obtenir des éléments de la file d'attente. Elle supprime et renvoie un élément.

de la file d'attente.

mettre() Cette méthode est utilisée pour insérer un élément dans la file d'attente.

cpu_count() Il retourne le nombre de CPU fonctionnels au sein du système.

processus_actuel() Il renvoie l'objet Process correspondant au processus actuel.

processus_parent() Il renvoie l'objet Process parent correspondant au processus actuel.

tâche_terminee() Cette fonction est utilisée pour indiquer qu'une tâche mise en file d'attente est terminée.

rejoindre_fils() Cette méthode est utilisée pour rejoindre le thread d'arrière-plan.