Share
Le package de multitraitement prend en charge les processus de génération utilisant une API similaire au module de threading. Il offre également une concurrence simultanée locale et distante. Ce tutoriel traitera du multitraitement dans Python et expliquera comment utiliser le multitraitement pour communiquer entre processus et effectuer la synchronisation entre processus, ainsi que la journalisation..
Le multitraitement fonctionne en créant un Processus objet puis en appelant début() méthode comme indiqué ci-dessous.
depuis un traitement multitraitement Processus def greeting (): affiche 'hello world' if __name__ == '__main__': p = Process (target = greeting) p.start () p.join ()
Dans l'exemple de code ci-dessus, nous importons d'abord la classe Process puis instancions l'objet Process avec la fonction de message d'accueil que nous souhaitons exécuter..
Nous disons ensuite au processus de commencer à utiliser le début() méthode, et nous avons finalement terminé le processus avec le joindre() méthode.
En outre, vous pouvez également passer des arguments à la fonction en fournissant le args argument de mot clé comme suit:
Accentsconagua
depuis un traitement multitraitement Processus de traitement du message d'accueil (nom): print 'bonjour' + "" + nom si __name__ == '__main__': p = Processus (cible = message d'accueil, args = ('monde',)) p.start () p .joindre() Regardons un exemple plus détaillé qui couvre tous les concepts que nous avons discutés ci-dessus.
Dans cet exemple, nous allons créer un processus qui calcule le carré des nombres et imprime les résultats sur la console..
depuis un traitement multitraitement Processus def square (x): pour x en chiffres: print ('% s au carré correspond à% s'% (x, x ** 2)) si __name__ == '__main__': numbers = [43, 50, 5, 98, 34, 35] p = Processus (cible = carré, args = ('x',)) p.start () p.join imprimer "Terminé" #résultat Terminé 43 carrés est de 1849 50 carrés est de 2500 5 carrés est 25 98 au carré est 9604 34 au carré est 1156 35 au carré est 1225 Vous pouvez également créer plusieurs processus à la fois, comme indiqué dans l'exemple ci-dessous, dans lequel le processus p1 obtient les résultats des nombres au carré, tandis que le second processus p2 vérifie si les nombres donnés sont pairs..
à partir de l'importation multitraitement Processus def square (x): pour x en chiffres: print ('% s au carré est% s'% (x, x ** 2)) def is_even (x): pour x en chiffres: si x% 2 == 0: print ('% s est un nombre pair'% (x)) si __name__ == '__main__': nombres = [43, 50, 5, 98, 34, 35] p1 = Processus (cible = carré, args = ('x',)) p2 = Processus (target = is_even, args = ('x',)) p1.start () p2.start () p1.join () p2.join () print "Terminé" #résultat 43 carré est 1849 50 carré est 2500 5 carré est 25 98 carré est 9 984 34 carré est 1156 35 carré est 1225 50 est un nombre pair 98 est un nombre pair 34 est un nombre pair Terminé Le multitraitement prend en charge deux types de canaux de communication entre processus:
Queue les objets sont utilisés pour transmettre des données entre les processus. Ils peuvent stocker n'importe quel objet Python compatible avec les pickles, et vous pouvez les utiliser comme indiqué dans l'exemple ci-dessous:
importer multitraitement def is_even (nombres, q): pour n nombres: si n% 2 == 0: q.put (n) si __name__ == "__main__": q = multitraitement.Queue () p = multitraitement.Process ( target = is_even, args = (intervalle (20), q)) p.start () p.join () tant que q: print (q.get ())
Dans l'exemple ci-dessus, nous créons d'abord une fonction qui vérifie si un nombre est pair, puis plaçons le résultat à la fin de la file d'attente. Nous instancions ensuite un objet de file d'attente et un objet de processus et commençons le processus..
Enfin, nous vérifions si la file est vide et si ce n’est pas le cas, nous obtenons les valeurs à partir du début de la file et nous les imprimons sur la console..
Nous avons montré comment partager des données entre deux processus à l'aide d'une file d'attente, et le résultat est présenté ci-dessous..
# résultat 0 2 4 6 8 10 12 14 16 18
Il est également important de noter que Python possède un module de file d'attente qui réside dans le module de processus et est utilisé pour partager des données entre des threads, contrairement à la file d'attente de multitraitement qui réside dans la mémoire partagée et est utilisée pour partager des données entre des processus..
Les tubes en multitraitement sont principalement utilisés pour la communication entre processus. L'utilisation est aussi simple que:
depuis un processus d'importation multitraitement, Pipe def f (conn): conn.send (['hello world']) conn.close () si __name__ == '__main__': parent_conn, child_conn = Pipe () p = Process (target = f , args = (child_conn,)) p.start () print parent_conn.recv () p.join ()
Tuyau() renvoie deux objets de connexion qui représentent les deux extrémités du tuyau. Chaque objet de connexion a envoyer() et recv () méthodes. Ici, nous créons un processus qui imprime la chaîne Bonjour le monde puis partage les données sur.
# result ['hello world']
Serrures travaillez en vous assurant qu'un seul processus est exécuté à la fois, empêchant ainsi d'autres processus d'exécuter du code similaire. Cela permet de terminer le processus et alors seulement, le verrou peut être libéré..
L'exemple ci-dessous montre une utilisation assez simple de la méthode Lock.
depuis un processus d'importation multitraitement, Verrouiller le message d'accueil (l, i): l.acquire () affiche 'bonjour', i l.release () si __name__ == '__main__': lock = Lock () noms = ['Alex', 'sam', 'Bernard', 'Patrick', 'Jude', 'Williams'] pour le nom dans les noms: Processus (cible = salutation, args = (verrou, nom)). start () #résultat bonjour Alex bonjour sam bonjour Bernard bonjour Patrick bonjour Jude bonjour Williams
Dans ce code, nous importons d’abord la méthode Lock, l’obtenons, exécutons la fonction print, puis nous le relâchons.
Le module de multitraitement prend également en charge la consignation, même si le progiciel de consignation n'utilise pas de verrous pour que les messages entre les processus puissent être mélangés au cours de l'exécution..
L'utilisation de la journalisation est aussi simple que:
importation multitraitement, journalisation de la journalisation = multitraitement.log_to_stderr () logger.setLevel (logging.INFO) logger.warning ('Une erreur est survenue')Ici, nous importons d’abord les modules de journalisation et de multitraitement, puis nous définissons la multiprocessing.log_to_stderr () méthode, qui effectue un appel à get_logger () ainsi que l'ajout d'un gestionnaire qui envoie la sortie à sys.stderr. Enfin, nous définissons le niveau de l’enregistreur et le message que nous voulons transmettre..
Ce didacticiel a présenté les éléments nécessaires pour bien démarrer le multitraitement en Python. Le multitraitement surmonte le problème de GIL (Global Interpreter Lock) car il exploite l'utilisation de sous-processus au lieu de threads.
La documentation Python contient de nombreux autres éléments qui ne sont pas abordés dans ce didacticiel. N'hésitez donc pas à consulter la documentation sur le multitraitement Python et à utiliser toute la puissance de ce module.
