Multiprocessing Python : définition et exemples

Avec le multiprocessing Python, vous pouvez répartir la charge de travail sur plusieurs processus afin de réduire le temps d’exécution total. C’est particulièrement avantageux pour les calculs volumineux ou les grandes quantités de données.

Qu’est-ce que le multiprocessing en Python ?

Le multiprocessing en Python désigne la capacité d’exécuter plusieurs processus simultanément, ce qui permet d’exploiter au mieux la puissance des systèmes multi-cœurs. Contrairement aux approches à un seul thread, dans lesquelles les tâches sont exécutées de manière séquentielle, le multiprocessing permet d’exécuter différentes parties du programme en parallèle et indépendamment les unes des autres. Chaque processus dispose de sa propre zone de mémoire et peut être traité sur des cœurs de processeur distincts, ce qui réduit considérablement le temps d’exécution des opérations nécessitant un calcul intensif ou d’être effectuées rapidement.

Les domaines d’application du multiprocessing Python sont multiples. Dans le traitement et l’analyse des données, le multiprocessing est souvent utilisé pour traiter plus rapidement de grands ensembles de données et accélérer les analyses complexes. Le multiprocessing peut également être utilisé dans les simulations et les calculs de modélisation, par exemple dans les applications scientifiques, afin de réduire les temps d’exécution des calculs complexes. De plus, le multiprocessing est utile dans le domaine du Web scraping pour la saisie simultanée de données provenant de différents sites Internet ou dans le traitement d’images et la vision par ordinateur pour améliorer l’efficacité des opérations d’analyse d’images.

Quelles sont les possibilités offertes par le multiprocessing en Python ?

Python offre différentes possibilités pour implémenter le multiprocessing. Nous vous présentons ci-dessous trois outils courants : le module multiprocessing, la bibliothèque concurrent.futures et le paquet joblib.

Le module multiprocessing

Le module multiprocessing est le module standard pour le multiprocessing en Python. Il permet la création de processus, l’échange de données entre ces processus et la synchronisation par des verrous, des files d’attente et d’autres mécanismes.

import multiprocessing
def task(n):
    result = n * n
    print(f"Result: {result}")
if __name__ == "__main__":
    processes = []
    for i in range(1, 6):
        process = multiprocessing.Process(target=task, args=(i,))
        processes.append(process)
        process.start()
    for process in processes:
        process.join()

Dans l’exemple ci-dessus, nous utilisons la classe multiprocessing.Process pour créer et lancer des processus qui exécutent la fonction task(). Celle-ci calcule le carré du nombre passé en paramètre. Les processus sont initiés et on attend qu’ils se terminent avant de poursuivre le programme principal. Nous affichons le résultat avec une f-String, une méthode String-Format en Python permettant d’intégrer des expressions. L’ordre est aléatoire et non décisif.

Vous pouvez également créer un pool de processus avec Python multiprocessing :

import multiprocessing
def task(n):
    return n * n
if __name__ == "__main__":
    with multiprocessing.Pool() as pool:
        results = pool.map(task, range(1, 6))
        print(results)  # Output: [1, 4, 9, 16, 25]

Avec pool.map(), la fonction task() est appliquée à une séquence de données, et les résultats sont collectés et affichés.

La bibliothèque concurrent.futures

Ce module offre une interface de haut niveau pour une exécution asynchrone et un traitement parallèle des processus. Il utilise le Pool-Executor pour exécuter des tâches sur un pool de processus ou de threads. Le module concurrent.futures est une manière plus simple de traiter des tâches asynchrones et est, dans de nombreux cas, plus facile à gérer que le module multiprocessing de Python.

import concurrent.futures
def task(n):
    return n * n
with concurrent.futures.ProcessPoolExecutor() as executor:
    futures = [executor.submit(task, i) for i in range(1, 6)]
    for future in concurrent.futures.as_completed(futures):
        print(future.result()) # result in random order

Le code utilise le module concurrent.futures pour traiter les tâches en parallèle avec le ProcessPoolExecutor. Pour cela, la fonction task(n) est passée pour les nombres de 1 à 5. La méthode as_completed() attend la fin des tâches et affiche les résultats dans n’importe quel ordre.

Le paquet joblib

joblib est une bibliothèque Python externe qui a été développée pour simplifier le traitement parallèle en Python, par exemple pour les tâches répétitives comme l’exécution de fonctions avec des paramètres d’entrée différents ou le travail avec de grandes quantités de données. Les fonctions principales de joblib se concentrent sur la parallélisation des tâches, la mise en cache des résultats de fonctions et l’optimisation des ressources de mémoire et de calcul.

from joblib import Parallel, delayed
def task(n):
    return n * n
results = Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))
print(results) # Output: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

L’expression Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11)) initie l’exécution parallèle de la fonction task() pour les nombres de 1 à 10. Parallel est configuré avec n_jobs=4, ce qui permet de traiter jusqu’à quatre jobs en parallèle. L’appel à delayed(task)(i) crée la tâche à exécuter en parallèle pour chaque nombre i dans la plage de 1 à 10. Cela signifie que la fonction task() est appelée simultanément pour chacun de ces nombres. Le résultat pour les nombres de 1 à 10 est enregistré dans results et sorti.