Synchronisation et pooling de processus en Python

Synchronisation entre processus

Le traitement multiplexé est un paquet de programme qui prend en charge la génération de programmes à l'aide de l'API. Ce paquet est utilisé pour la concurrence locale et distante. En utilisant ce module, les programmeurs peuvent utiliser plusieurs processeurs sur l'ordinateur donné. Il peut s'exécuter sur les systèmes d'exploitation Windows et UNIX.

Ce programme contient toutes les primitives de synchronisation équivalentes.

Exemple de code

from multiprocessing import Process, Lock
　　　def my_function(x, y):
　　　　　　x.acquire()
　　　　　　imprime('hello world', y)
　　　　　　x.release()
　　　　　　if __name__ == '__main__':
　　　　　　lock = Lock() pour num dans range(10) :
Process(target=my_function, args=(lock, num)).start()

Ici, une instance peut être verrouillée pour s'assurer qu'un seul processus peut afficher le sortie standard à la fois.

Rassemblement

Pour le pool, nous utilisons la classe Pool. Lorsqu'une personne peut créer un pool de processus, il portera toutes les tâches soumises.

class multiprocessing.Pool([processes[, initializer[, initargs[, maxtasksperchild]]]])

L'objet de pool contrôle le pool de travail pour sélectionner les tâches pouvant être soumises, il prend en charge les résultats asynchrones, les retours d'appel et la mise en œuvre de la cartographie parallèle.

Si le processus est vide, utilisez cpu_count() ; si l'initialisation n'est pas none, utilisez initializer(* Appeler cette fonction avec initargs).

apply(func[, args[, kwds]])

Cela est similaire àapply()Fonction intégrée similaire. Cette méthode bloquera jusqu'à ce que les résultats soient prêts, et apply_async() est préférable pour l'exécution en parallèle.

apply_async(func[, args[, kwds[, callback]]])

Retourne un objet de résultat.

map(func, itérable[, chunksize])

map() est une fonction intégrée qui ne prend qu'un seul paramètre itérable. Elle bloque jusqu'à ce que les résultats soient prêts.

Dans cette méthode, l'itérable est décomposé en plusieurs morceaux et ces morceaux sont soumis en tant que tâches individuelles au pool de processus.

map_async(func, iterable[, chunksize[, callback]])

Retourne un objet de résultat.

imap(func, iterable[, chunksize])

Comme itertools.imap().

La taille des paramètres est la même que celle utiliséemap().

imap_unordered(func, iterable[, chunksize])

Cela est similaire àimap()Redéfinir l'ordre de l'itérateur de la même manière.

Fermer()

Le travailleur quitte le processus une fois toutes les tâches terminées.

Terminer()

Si nous voulons arrêter immédiatement le processus de travail sans terminer la tâche, utilisons cette méthode.

join()

Lorsquejoin()Avant d'utiliserclose()etterminate()fonction.

classe multiprocessing.pool.AsyncResult

Retourné par Pool.apply_async() et Pool.map_async().

get ([délai])

Cette fonction retourne le résultat à l'arrivée.

Attendre ([délai])

En utilisant cette fonction d'attente, nous attendons que le résultat soit disponible ou jusqu'à ce que le secondaire s'est écoulé en secondes.

Prepare()

Cette fonction retourne si l'appel est terminé.

Success()

Aucune erreur ne s'est produite après l'appel, cette fonction retournera.

Exemple de code

#　-*-　coding: utf-8　-*-
"""
Created on Sun Sep　30　12:17:58　2018
@author: oldtoolbag.com
"""
from multiprocessing import Pool
import time
def myfunction(m):
return m*m
if __name__ == '__main__':
my_pool = Pool(processes=4) # start　4　worker processes
result = my_pool.apply_async(myfunction, (10,)10)) "asynchronously in a single process
print (result.get(timeout=)1))
print (my_pool.map(myfunction, (10)) # imprime "[0,"　1,　4,...,　81])
my_it = my_pool.imap(myfunction, (10))
print (my_it.next() ) # imprime "0"
print (my_it.next() ) # imprime "1"
print (my_it.next(timeout=)1) ) # imprime "4" unless your computer is　*very*　slow
result = my_pool.apply_async(time.sleep, (10,)
print (result.get(timeout=)1) ) # lève une erreur TimeoutError