Comment mettre en œuvre au mieux le multitraitement en Python?

Cet article vous présentera le multitraitement en Python et en cours de traitement finira également par vous donner une démonstration programmatique.

2019 a été une très grande année pour le développement technologique dans le monde entier. À partir des fabricants d'ordinateurs ajoutant plus de cœurs à leurs processeurs et processeurs au lancement de puces plus intelligentes dans les téléphones mobiles, le multitraitement n'est plus un rêve. Aujourd'hui, l'un des langages de programmation les plus importants prenant en charge le multitraitement est . Grâce à l'introduction de la puissance de traitement parallèle dans sa version, les codeurs du monde entier peuvent désormais créer de manière transparente des codes à exécuter simultanément et donc leur durée d'exécution de manière significative.



Les pointeurs suivants seront traités dans cet article,



pl sql pour les débutants avec des exemples

Commençons,

Multitraitement en Python

Qu'est-ce que le multitraitement?

Le multitraitement peut simplement être défini comme la capacité d'un système à prendre en charge plus d'une opération à une instance donnée. Cela signifie que les applications des systèmes multiprocesseurs sont décomposées en petits morceaux, puis exécutées indépendamment les unes des autres afin d'augmenter l'efficacité et de réduire le temps d'exécution global. Le processeur du système attribue à chaque petit morceau un thread indépendant qui lui est propre, lui permettant ainsi de fonctionner comme une entité autonome.



La nécessité du multitraitement

Imaginez un système informatique qui n'a qu'un seul cœur dans son processeur. Si plusieurs tâches sont affectées à ce noyau unique, il doit interrompre chaque tâche entre les deux, puis passer à la suivante. Cela n'augmentera pas le temps nécessaire pour terminer chaque tâche, mais réduira également l'efficacité globale du système.

D'un autre côté, un ordinateur multitraitement peut avoir un processeur qui à son tour a plusieurs unités fonctionnelles à l'intérieur, appelées cœurs individuels qui ont la capacité d'exécuter plusieurs tâches différentes indépendamment en même temps. Cela augmente non seulement l'efficacité du système, mais réduit également à long terme la durée d'exécution du système de manière significative.



Un système multiprocesseur en Python peut être de deux types.

Système multiprocesseur

Ce système a essentiellement plusieurs processeurs présents sous son capot, chacun pouvant effectuer une tâche à la fois et fonctionner comme un composant indépendant.

Système de processeur multicœur

Ce système a plusieurs cœurs présents dans le même processeur, au sein desquels le cœur fonctionne comme une unité distincte et exécute indépendamment les tâches qui lui sont assignées.

Code pour le multitraitement en Python

Maintenant que vous êtes habitué au concept de base du multitraitement, explorons comment le multitraitement peut être réalisé en Python.

En Python, l'interpréteur contient une API très simple et intuitive qui prend une seule tâche, la décompose en plusieurs composants et les fait traiter indépendamment.

Jetez un œil au module de programme ci-dessous pour mieux comprendre ce concept de multitraitement en python.

Exemple 1

# importation du module multitraitement import multitraitement def print_cube (num): '' 'fonction pour imprimer le cube d'un nombre donné' '' print ('Cube: {}'. format (num * num * num)) def print_square (num): '' 'fonction pour imprimer un carré de nombre donné' '' print ('Square: {}'. format (num * num)) if __name__ == '__main__': # création de processus p1 = multiprocessing.Process (target = print_square, args = (10,)) p2 = multiprocessing.Process (target = print_cube, args = (10,)) # démarrage du processus 1 p1.start () # démarrage du processus 2 p2.start () # attendre la fin du processus 1 p1 .join () # attend que le processus 2 soit terminé p2.join () # les deux processus sont terminés print ('Done!')

Production

Carré: 100

Cube: 1000

Terminé!

Analysons maintenant ce programme pour mieux le comprendre.

  1. La première étape consiste à importer le module multitraitement. Pour ce faire, utilisez la syntaxe suivante: import multiprocessing.

  2. Maintenant que le module multitraitement a été importé, allons de l'avant et créons un processus. Pour ce faire, nous créons un objet de la classe Process et lui attribuons les arguments suivants. Target: la fonction qui doit être exécutée par ce processus et args: les arguments qui doivent être passés à la fonction cible.

Remarque: Un constructeur de processus a la capacité de prendre plusieurs cibles ainsi que des arguments, mais dans l'exemple ci-dessus, nous n'avons attribué à notre processus que deux cibles et arguments comme indiqué ci-dessous.

p1 = multiprocessing.Process (cible = print_square, args = (10,))

p2 = multiprocessing.Process (cible = print_cube, args = (10,))

  1. Maintenant que le processus a été créé, écrivons la syntaxe pour le démarrer.

p1.start ()

p2.start ()

Une fois le processus lancé, le programme en cours et celui déjà en cours d'exécution sont exécutés simultanément. Si dans une certaine situation, vous devez arrêter l'exécution du programme en cours et vous concentrer uniquement sur l'exécution du programme préexistant, nous utilisons la fonction de jointure comme indiqué ci-dessous.

p1.join ()

p2.join ()

Une fois que vous avez saisi cette syntaxe, l'interpréteur attendra que le programme p1 termine l'exécution, puis passera au programme p2.

Pour mieux comprendre ce concept, jetez un œil à un autre exemple de multitraitement en Python ci-dessous.

Exemple 2

# importation du module multitraitement import import multitraitement os def worker1 (): # print process id print ('ID du processus en cours d'exécution worker1: {}'. format (os.getpid ())) def worker2 (): # printing process id print ('ID du processus exécutant worker2: {}'. Format (os.getpid ())) if __name__ == '__main__': # impression de l'id du processus du programme principal print ('ID du processus principal: {}'. Format (os .getpid ())) # création de processus p1 = multiprocessing.Process (target = worker1) p2 = multiprocessing.Process (target = worker2) # processus de démarrage p1.start () p2.start () # process IDs print ('ID of processus p1: {} '. format (p1.pid)) print (' ID du processus p2: {} '. format (p2.pid)) # attend que les processus soient terminés p1.join () p2.join () # les deux processus ont terminé print ('Les deux processus ont terminé leur exécution!') # vérifie si les processus sont actifs print ('Le processus p1 est actif: {}'. format (p1.is_alive ())) print ('Le processus p2 est actif: {} '.format (p2.is_alive ()))

Production

Identifiant du processus principal: 18938

ID du processus en cours d'exécution worker1: 18939

méthode python __init__

ID du processus en cours d'exécution worker2: 18940

ID du processus p1: 18939

Identifiant du processus p2: 18940

Les deux processus ont terminé l'exécution!

Le processus p1 est actif: Faux

Le processus p2 est actif: Faux

Notez dans le programme ci-dessus que les deux processus p1 et p2 fonctionnent indépendamment de leurs mémoires individuelles. Dès que les deux ont terminé l'exécution, le programme se termine.

Cela nous amène à la fin de cet article sur le multitraitement en Python

Pour acquérir des connaissances approfondies sur Python et ses différentes applications, vous pouvez pour une formation en ligne en direct avec une assistance 24/7 et un accès à vie.

Vous avez une question pour nous? Mentionnez-les dans la section commentaires de l'article et nous vous recontacterons.