Quelle méthode de pool dois-je utiliser dans le multitraitement Python ?

Multiprocessing.Pool : quelle méthode dois-je utiliser ?

Le multitraitement permet à Python d'exécuter des fonctions simultanément sur plusieurs processus. Cependant, choisir la méthode appropriée peut prêter à confusion, en particulier si l'on considère Pool.apply, Pool.apply_async et Pool.map. Clarifions leurs différences et leurs cas d'utilisation :

Pool.apply vs Pool.apply_async vs Pool.map

1. Pool.apply :

• Appelle une fonction dans un processus distinct et bloque le processus en cours jusqu'au retour de la fonction.
• À utiliser lorsque vous devez effectuer un seul appel de fonction et attendez le résultat immédiatement.

2. Pool.apply_async :

• Similaire à Pool.apply, appelle une fonction dans un processus distinct, mais renvoie immédiatement.
• Renvoie un objet AsyncResult qui vous permet de récupérer le résultat plus tard.
• Prend en charge les fonctions de rappel qui sont invoquées lorsque le résultat est disponible.
• Utile pour le traitement asynchrone de plusieurs appels de fonction.

3. Pool.map :

• Appelle la même fonction sur une séquence d'arguments en parallèle.
• Bloque jusqu'à ce que tous les résultats soient obtenus.
• Préserve l'ordre des arguments et des résultats.
• Idéal pour appliquer la même fonction à plusieurs points de données et obtenir une liste de résultats dans le même ordre.

Choisir la bonne méthode

Utilisez Pool.apply si :

• Vous devez bloquer jusqu'à ce qu'une seule fonction revienne.
• Vous ne voulez pas pour gérer le traitement asynchrone.

Utilisez Pool.apply_async si :

• Vous souhaitez appeler plusieurs fonctions de manière asynchrone et récupérer leurs résultats plus tard.
• Vous souhaitez utiliser des rappels pour gérer les résultats.

Utilisez Pool.map si :

• Vous devez appliquer la même chose fonction sur plusieurs arguments simultanément.
• Vous souhaitez conserver l'ordre argument-résultat.

Exemple : rappel asynchrone dans Pool.apply_async

<code class="python">import multiprocessing as mp
import time

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

result_list = []
def log_result(result):
    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()</code>

Sortie :

[1, 0, 4, 9, 25, 16, 49, 36, 81, 64]

Notez que l'ordre des résultats peut ne pas correspondre à l'ordre des appels de fonction, contrairement à Pool.map.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!