Multiprocessing en Python

多处理程序包支持生成过程。它是指加载和执行新的子进程的函数。为了让孩子终止或继续执行并发计算，则当前进程必须使用类似于线程模块的API等待。

介绍

当我们使用Multiprocessing时，首先要创建过程对象。然后，它调用一个start()方法。

范例程式码

from multiprocessing import Process
　　　def display():
　　　　　　print('Hi !! Je suis Python')
　　　　　　if __name__ == '__main__':
　　　　　　p = Process(target=display)
　　　　　　p.start()
　　　　　　p.join()

在此示例中，首先我们导入Process类，然后使用该display()函数启动Process对象。

然后，用start()方法开始处理，然后用该join()方法完成处理。

我们还可以使用args关键字将参数传递给函数。

Exemple

from multiprocessing import Process
　　　def display(my_name):
　　　print('Hi !!!')　+　"　"　+　my_name)
　　　if __name__ == '__main__':
　　　　　　p = Process(target=display, args=('Python',))
　　　　　　p.start()
　　　　　　p.join()

在此示例中，我们创建一个过程，该过程计算数字的立方并将所有结果打印到控制台。

范例程式码

from multiprocessing import Process
　　　def cube(x):
　　　　　　for x in my_numbers:
　　　　　　　　　print('%s cube est %s' % (x, x)**3))
　　　　　　if __name__ == '__main__':
　　　　　　　　　my_numbers = [3,　4,　5,　6,　7,　8]
　　　　　　　　　p = Process(target=cube, args=('x',))
　　　　　　　　　p.start()
p.join
print　("Terminé")

Résultat de la sortie

Terminé
3　le cube est　27
4　le cube est　64
5　le cube est　125
6　le cube est　216
7　le cube est　343
8　le cube est　512

我们也可以一次创建多个流程。

在此示例中，首先我们创建一个进程，即process1，该进程仅计算一个数字的立方，与此同时，第二个进程process2正在检查该数字是偶数还是奇数。

Exemple

from multiprocessing import Process
def cube(x):
　　　for x in my_numbers:
　　　print('%s cube est %s' % (x, x)**3))
def evenno(x):
　　　for x in my_numbers:
　　　if x %　2　==　0:
　　　print('%s est un nombre pair' % (x))
　　　if __name__ == '__main__':
　　　　　　my_numbers = [3,　4,　5,　6,　7,　8]
　　　　　　my_process1　=　Process(target=cube,　args=('x',))
　　　　　　my_process2　=　Process(target=evenno,　args=('x',))
　　　　　　my_process1.start()
　　　　　　my_process2.start()
　　　　　　my_process1.join()
　　　my_process2.join()
print　("Terminé")

Résultat de la sortie

3　le cube est　27
4　le cube est　64
5　le cube est　125
6　le cube est　216
7　le cube est　343
8　le cube est　512
4　est un nombre pair
6　est un nombre pair
8　est un nombre pair
Terminé

La communication entre les processus

Le traitement multiprocessus prend en charge les tubes et les files d'attente, qui sont deux canaux de communication entre les processus.

Le tuyau

Dans le traitement multiprocessus, lorsque nous devons communiquer entre des processus, dans ce cas, utilisezLe tube。

Exemple

from　multiprocessing　import　Process,　Pipe
　　　def　myfunction(conn):
　　　　　　conn.send(['hi!!　I　am　Python'])
　　　　　　conn.close()
　　　　　　if __name__ == '__main__':
　　　　　　　　　parent_conn,　child_conn　=　Pipe()　　　　　　　　　p　=　Process(target=myfunction,　args=(child_conn,))
　　　　　　　　　p.start()
　　　　　　print　(parent_conn.recv()　)
p.join()

Résultat de la sortie

['hi　!!!　I　am　Python']

Le tube retourne deux objets connectés, représentant les deux extrémités du tube. Chaque objet connecté a deux méthodessend()，une estrecv()Méthode, une autre est méthode.

Dans cet exemple, tout d'abord, nous créons un processus qui affiche le message "hi !! I am Python", puis partage les données.

s列

Lorsque nous transmettons des données entre des processus, à ce moment-là, nous pouvons utiliser l'objet Queue.

Exemple

import　multiprocessing
　　　def　evenno(numbers,　q):
　　　　　　for　n　in　numbers:
　　　　　　if　n　%　2　==　0:
　　　　　　q.put(n)
　　　　　　if　__name__　==　"__main__":
　　　　　　　　　q　=　multiprocessing.Queue()
　　　　　　　　　p　=　multiprocessing.Process(target=evenno,　args=(range(10),　q))
　　　　　　　　　p.start()
　　　　　　　　　p.join()
　　　while　q:
print(q.get())

Résultat de la sortie

0
2
4
6
8

Dans cet exemple, tout d'abord, créez une fonction pour vérifier si le temps est pair. Si le nombre est pair, insérez-le à la fin de la file. Ensuite, créez un objet file et un objet flux, puis démarrez le flux.

Enfin, vérifiez si la file d'attente est vide.

Lorsque nous imprimons des nombres, nous imprimons d'abord la valeur en tête de la file d'attente, puis la suivante, et ainsi de suite.

Verrous

Dans ce cas, si nous voulons exécuter un seul processus à la fois, nous utilisons Locks. Cela signifie que le temps empêchera d'autres processus d'exécuter un code similaire. Une fois le processus terminé, le verrou est libéré.

Exemple d'utilisation de la méthode Locks

Exemple

from multiprocessing import Process, Lock
def dispmay_name(l, i):
l.acquire()
print('Hi', i)
　　　l.release()
if __name__ == '__main__':
　　　my_lock = Lock() my_name = ['Aadrika', 'Adwaita', 'Sakya', 'Sanj']
for name in my_name:
Process(target=dispmay_name, args=(my_lock, name)).start()

Résultat de la sortie

Hi Aadrika
Hi Adwaita
Hi Sakya
Hi Sanj

Enregistrement

Le module de multiprocessus fournit également un module de journalisation pour s'assurer que si le paquet de journalisation ne utilise pas la fonction de verrouillage, les messages entre les processus se mélangent pendant l'exécution.

Exemple

import multiprocessing, logging
logger = multiprocessing.log_to_stderr()
logger.setLevel(logging.INFO)
logger.warning('Une erreur est survenue')

Dans cet exemple, tout d'abord, importez les modules de journalisation et de multiprocessus, puis utilisez la méthode multiprocessing.log_to_stderr(). Ensuite, appellez get_logger() et ajoutez-le à sys.stderr. Enfin, nous définissons le niveau du journaliste et transmettons des messages.