Effectuer un traitement parallèle en Python

1. Utiliser le pool de traitement et ses méthodes pour effectuer un multitraitement en Python
2. Utilisez la fonction apply_async() pour effectuer un multitraitement en Python
3. Utilisez les fonctions map() et map_sync() pour effectuer un multitraitement en Python

Cet article explique comment exécuter plusieurs processus en parallèle en Python.

Utiliser le pool de traitement et ses méthodes pour effectuer un multitraitement en Python

Pour effectuer le multitraitement en Python, procédez comme suit.

• Tout d’abord, importez le module multiprocessing.
• Utilisez la classe Pool pour définir le pool de traitement Python. Ce pool représente un pool de processus de travail. Prenez l’extrait de code ci-dessous comme exemple.

Pool(processes=n)

Ainsi, la classe Pool permettra au nombre n de processus de s’exécuter simultanément. Cette classe contient des méthodes qui permettent la délégation de tâches aux processus de travail du pool.

Voici quelques-unes des méthodes de la classe Pool.

• Pool.map() - Utilisez cette méthode de blocage du Pool pour bloquer jusqu’à ce que le résultat soit prêt. Cette méthode découpe l’itérable associé en plusieurs morceaux. Ensuite, il soumet les morceaux au pool de processus en tant que tâches distinctes.

• Utilisez les méthodes non bloquantes suivantes de la classe Pool pour soumettre les processus simultanément en une seule fois. Utilisez la méthode get() pour obtenir les résultats de la fonction.

• Pool.apply_async()

• Pool.map_async()

Pour déterminer le nombre de processus que votre machine peut gérer pour le multitraitement, vous devez connaître le nombre de processeurs que vous avez dans votre appareil ; vous pouvez le vérifier en utilisant le code suivant.

import multiprocessing as mp

print("Number of processors: ", mp.cpu_count())

Production:

Number of processors:  4

Utilisez la fonction apply_async() pour effectuer un multitraitement en Python

Voici un exemple illustrant le multitraitement à l’aide du pool de traitement en Python tout en déterminant le carré d’une plage sur des nombres de 0 à 9.

Notez qu’ici, nous avons même imprimé le nom du Process worker, qui est facultatif.

from multiprocessing import Pool
from multiprocessing import Process, current_process
import time
from time import sleep
import random


def fnc_square(x):
    print(current_process().name)
    return x * x


if __name__ == "__main__":
    pool = Pool(processes=4)
    result = pool.apply_async(fnc_square, [6])
    print(result.get(timeout=1))
    print(pool.map(fnc_square, range(10)))

Production:

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

Utilisez les fonctions map() et map_sync() pour effectuer un multitraitement en Python

La fonction map_async est non bloquante, alors que la fonction map est bloquante. Vous trouverez ci-dessous un exemple qui illustre la différence entre ces deux commandes.

from multiprocessing import Pool
import time


def f(x):
    print(x * x)


if __name__ == "__main__":
    pool = Pool(processes=1)
    pool.map(f, range(10))
    r = pool.map_async(f, range(10))
    print("First print")
    print("Second print")
    r.wait()
    print("Third print")

Ici, nous pouvons observer que la fonction pool.map() attendra la fin des 10 appels d’opération. Par conséquent, nous voyons le résultat imprimé dans l’ordre.

De plus, le pool.map_async() exécutera les 10 appels de fonction de manière asynchrone. Lorsque la fonction r.wait() est appelée, elle bloque l’exécution du processeur. Par conséquent, dans la sortie, nous voyons les messages d’impression comme First print et Second print entre les deux, mais le Third print sera toujours à la fin.

Production:

0
1
4
9
16
25
36
49
64
81
First print
Second print
0
1
4
9
16
25
36
49
64
81
Third print