multitraitement.Piscine: utilisation s'appliquent, apply_async ou de la carte?

Je n'ai pas vu des exemples clairs avec des cas d'utilisation pour Piscine.appliquer, Piscine.apply_async et Piscine.carte. Je suis principalement à l'aide de Pool.map; quels sont les avantages des autres?

InformationsquelleAutor Phyo Arkar Lwin | 2011-12-16

388

De retour dans les vieux jours de Python, pour appeler une fonction avec des arguments arbitraires, vous pouvez utiliser apply:
```
apply(f,args,kwargs)
```
apply existe encore dans Python2.7 mais pas en Python3, et n'est généralement pas utilisé plus. De nos jours,
```
f(*args,**kwargs)
```
est préféré. Le multiprocessing.Pool modules tente de fournir une interface similaire.

Pool.apply est comme Python apply, sauf que l'appel de la fonction est exécutée dans un processus séparé. Pool.apply blocs jusqu'à ce que la fonction est terminée.

Pool.apply_async est aussi comme Python intégré dans apply, sauf que l'appel renvoie immédiatement au lieu d'attendre le résultat. Un AsyncResult objet est retourné. Vous appelez sa get() méthode pour récupérer le résultat de l'appel de la fonction. Le get() méthode des blocs jusqu'à ce que la fonction est terminée. Ainsi, pool.apply(func, args, kwargs) est équivalent à pool.apply_async(func, args, kwargs).get().

Contrairement à Pool.apply, le Pool.apply_async méthode a aussi un rappel qui, s'il est fourni, est appelée lorsque la fonction est terminée. Ceci peut être utilisé au lieu de l'appeler get().

Par exemple:
```
import multiprocessing as mp
import time

def foo_pool(x):
    time.sleep(2)
    return x*x

result_list = []
def log_result(result):
    # This is called whenever foo_pool(i) returns a result.
    # result_list is modified only by the main process, not the pool workers.
    result_list.append(result)

def apply_async_with_callback():
    pool = mp.Pool()
    for i in range(10):
        pool.apply_async(foo_pool, args = (i, ), callback = log_result)
    pool.close()
    pool.join()
    print(result_list)

if __name__ == '__main__':
    apply_async_with_callback()
```
peut donner un résultat comme celui
```
[1, 0, 4, 9, 25, 16, 49, 36, 81, 64]
```
Avis, contrairement à pool.map, l'ordre des résultats peut ne pas correspondre à l'ordre dans lequel les pool.apply_async appels ont été effectués.

Donc, si vous avez besoin pour exécuter une fonction dans un processus séparé, mais souhaitez que le processus actuel de bloc jusqu'à ce que la fonction retourne une valeur, utiliser Pool.apply. Comme Pool.apply, Pool.map blocs jusqu'à ce que le résultat complet est retourné.

Si vous voulez la Piscine de processus de travail pour effectuer de nombreux appels de fonction en mode asynchrone, utilisation Pool.apply_async. Le ordre des résultats n'est pas garanti d'être le même que l'ordre des appels à Pool.apply_async.

Notez également que vous pourriez appeler un numéro de différents fonctions avec Pool.apply_async (tous les appels ne doivent utiliser la même fonction).

En revanche, Pool.map s'applique de la même fonction à plusieurs arguments.
Cependant, contrairement à Pool.apply_async, les résultats sont affichés dans un ordre correspondant à l'ordre des arguments.
- Devrait-il y avoir if __name__=="__main__" avant apply_async_with_callback() sur Windows?
- Merci beaucoup. que diriez-map_async?
- Regardez à l'intérieur de multiprocessing/pool.py et vous verrez que Pool.map(func,iterable) est équivalent à Pool.map_async(func,iterable).get(). Ainsi, la relation entre Pool.map et Pool.map_async est similaire à celle de Pool.apply et Pool.apply_async. Le async commandes renvoient immédiatement, tandis que la non-async commandes de bloc. Le async commandes ont également une fonction de rappel.
- Décider entre l'utilisation de Pool.map et Pool.apply est similaire à décider quand utiliser map ou apply en Python. Il vous suffit d'utiliser l'outil qui convient pour le poste. Décider entre l'utilisation de la async et nonasync version dépend si vous voulez que l'appel à bloquer le processus en cours et/ou si vous souhaitez utiliser la fonction de rappel.
- rappel des sons plus vraiment async! je vais le tester!
- La commande est garantie si vous utilisez une compréhension de liste comme cet exemple dans l'officiel docs? par exemple, multiple_results = [pool.apply_async(os.getpid, ()) for i in range(4)] print [res.get(timeout=1) for res in multiple_results]
- Oui. Chaque appel à apply_async retourne un ApplyResult objet. L'appel que ApplyResult's get méthode retourne la fonction associée de la valeur de retour (ou de relancer mp.TimeoutError si l'appel est terminé.) Donc, si vous mettez le ApplyResults dans une liste ordonnée, puis l'appel de leur get méthodes renvoie les résultats dans le même ordre. Vous pouvez simplement utiliser pool.map dans cette situation.
- Merci. J'ai considéré la piscine.la carte, mais je veux utiliser un for boucle au lieu de compréhension de liste pour définir les arguments de chaque processus, depuis que je suis passer plusieurs arguments à chaque processus. Certains arguments sont propres à chaque processus, certains sont constants chez tous les, et certains sont constants chez un sous-ensemble de tous les processus. À l'aide de starmap et les autres devient assez salissant pour ce cas. Aussi, je veux qu'il fonctionne dans les deux python 2 et 3.
- Je veux exécuter une fonction dans le fond, mais j'ai quelques limitations de ressources et ne peut pas exécuter la fonction autant de fois que je veux et veux la file d'attente supplémentaire de l'exécution de la fonction. Avez-vous une idée sur comment je dois faire? J'ai à ma question here. Pourriez vous s'il vous plaît prendre un coup d'oeil à ma question et voir si vous pouvez me donner quelques conseils (ou encore mieux, une réponse) sur comment je dois faire?
- Si nous utilisons callback dans pool.apply_async comme dans cet exemple, nous avons la garantie de la protection de l'écriture sur la variable partagée result_list?
- Chaque fois que le travailleur de la fonction se termine avec succès (sans lever une exception), la fonction de rappel est appelée dans le processus principal. Le travailleur fonctions de mettre les valeurs de retour dans une file d'attente, et le pool._result_handler thread dans le processus principal gère les valeurs retournées une à une, en passant la valeur renvoyée de la fonction de rappel. Donc vous avez la garantie que la fonction de callback sera appelée une fois pour chaque valeur retournée et il n'y a pas de simultanéité problème ici parce que la fonction de rappel est appelée de manière séquentielle par un seul thread dans le processus principal.
- Le seul inconvénient est que vous devez appeler pool.join() avant d'inspecter result_list ou bien il peut ne pas contenir tous les résultats. (Après tout, pool.join() est dire le processus principal d'attendre jusqu'à ce que toutes les tâches ont fini.)
- n'est pas une variable partagée. Bien qu'il puisse exister dans le processus de travail, il est uniquement destinée à être modifiée et est accessible par le processus principal. Si vous ne modifiez result_list dans un processus de travail, la valeur ne sera pas vu par le processus principal.
- merci pour la clarification détaillée! Les préoccupations soulagé. Ce rappel à l'approche fondée sur semble plus facile d'agréger les résultats de plusieurs processus de travail. Une chose que j'ai remarqué, c'est la restriction de n'être en mesure de passer un paramètre à la fonction de rappel. Ainsi, il semble que je ne peux pas mettre cette fonction de rappel et de la liste de résultats en tant que membres de la classe, mais seulement de les placer comme celles du monde entier. Toute solution pour cela?
- href="https://ideone.com/FaWOoQ" >Il est possible pour faire le rappel, et result_list membres d'une classe. Dans les liens exemple, foo.log_result est ce qu'on appelle un méthode liée. L'accès foo.log_result retourne une fonction avec l'instance foo "liés", dans le sens que l'appel foo.log_result(x) est équivalent à Foo.log_result(foo, x). Notez que foo obtient passé comme premier argument.
InformationsquelleAutor unutbu
73

Concernant apply vs map:

pool.apply(f, args): f n'est exécuté dans l'UN des travailleurs de la piscine. Si l'UN des processus dans la piscine sera exécuté f(args).

pool.map(f, iterable): Cette méthode côtelettes l'objet iterable dans un certain nombre de morceaux qu'il soumet au processus de la piscine comme des tâches distinctes. Ainsi, vous profitez de tous les processus dans la piscine.
- que faire si l'itérable est un générateur de
- Hum... Bonne question. Pour être honnête, je n'ai jamais utilisé de piscines avec des générateurs, mais ce fil pourrait être utile: stackoverflow.com/questions/5318936/...
- Concernant les appliquer, si un seul des travailleurs d'exécuter la fonction, ce qui ne le reste des travailleurs? Dois-je appeler appliquer plusieurs fois pour avoir le reste des travailleurs d'accomplir une tâche?
- Vrai. Jetez aussi un oeil à la piscine.apply_async si vous souhaitez déjeuner travailleurs de manière asynchrone. "pool_apply blocs jusqu'à ce que le résultat est prêt, donc apply_async() est mieux adapté pour effectuer un travail en parallèle"
InformationsquelleAutor kakhkAtion

Vous devez vous connecter pour publier un commentaire.