Programmation concurrente : concurrent.futures vs. multiprocessing

Introduction

La programmation concurrente vous permet d’effectuer plusieurs opérations simultanément, améliorant ainsi l’efficacité de vos applications Python, en particulier pour les tâches liées au processeur ou aux entrées-sorties. En Python, deux approches populaires pour la concurrence sont le module de haut niveau concurrent.futures et le module de bas niveau multiprocessing. Dans cet article, nous proposons une comparaison pratique de ces deux méthodes, nous démontrons leur utilisation à l’aide d’exemples et nous offrons des points de repère pour vous aider à choisir la meilleure option pour vos besoins.

Vue d’ensemble: concurrent.futures vs. multiprocessing

concurrent.futures

Le module concurrent.futures fournit une interface de haut niveau pour l’exécution asynchrone d’objets appelables à l’aide de threads ou de processus. Ses composants clés sont:
- ThreadPoolExecutor: Pour les tâches liées aux E/S.
- ProcessPoolExecutor: Pour les tâches liées à l’unité centrale.

Ce module simplifie le processus de gestion de la concurrence à l’aide d’une API cohérente.

multiprocessing

Le module multiprocessing permet de créer plusieurs processus, chacun disposant de son propre interpréteur Python et de son propre espace mémoire. Il est idéal pour les tâches liées au processeur et permet un contrôle plus fin de la création et de la communication des processus, bien qu’il nécessite plus de code de base que concurrent.futures.

Exemples pratiques

Vous trouverez ci-dessous des exemples côte à côte illustrant l’utilisation des deux modules pour effectuer un calcul simple, à savoir le calcul du carré des nombres d’une liste.

Utiliser concurrent.futures (ProcessPoolExecutor)

import concurrent.futures
import time

def square(n):
    time.sleep(0.5)  # Simuler une opération liée à l'unité centrale
    return n * n

if __name__ == "__main__":
    numbers = [1, 2, 3, 4, 5]
    with concurrent.futures.ProcessPoolExecutor(max_workers=3) as executor:
        results = list(executor.map(square, numbers))
    print("Results with concurrent.futures:", results)

Utiliser multiprocessing.Pool

import multiprocessing
import time

def square(n):
    time.sleep(0.5)  # Simuler une opération liée à l'unité centrale
    return n * n

if __name__ == "__main__":
    numbers = [1, 2, 3, 4, 5]
    with multiprocessing.Pool(processes=3) as pool:
        results = pool.map(square, numbers)
    print("Results with multiprocessing:", results)

Aperçu de l’analyse comparative

Note

Note: Les résultats du benchmark peuvent varier en fonction de la configuration du système et de la charge de travail. En général, pour les tâches liées au processeur, ProcessPoolExecutor et multiprocessing.Pool ont des performances similaires. Cependant, concurrent.futures offre une API plus conviviale et une meilleure gestion des erreurs, tandis que multiprocessing offre un contrôle plus fin.

Quand utiliser chaque approche

• Utiliser concurrent.futures si:
  • Vous préférez une API plus simple et de plus haut niveau.
  • Vous traitez les tâches liées aux E/S avec ThreadPoolExecutor ou les tâches liées au processeur avec ProcessPoolExecutor.
  • Vous voulez un support intégré pour les futures, ce qui facilite la gestion des erreurs et l’annulation.
• Utiliser multiprocessing si:
  • Vous avez besoin d’un meilleur contrôle sur la gestion des processus et la communication inter-processus.
  • Votre application est fortement liée au processeur et vous devez optimiser l’utilisation des ressources.
  • Vous êtes à l’aise avec plus de code standard pour la gestion des processus.

Conclusion

Les modules concurrent.futures et multiprocessing offrent tous deux des solutions robustes pour la programmation concurrente en Python. Votre choix dépend des exigences spécifiques de vos tâches et de votre préférence pour la simplicité par rapport au contrôle. Expérimentez les deux approches pour déterminer celle qui convient le mieux à votre charge de travail et envisagez d’utiliser des outils d’analyse comparative pour mesurer les performances dans votre environnement spécifique.

Plus d’informations

• Traitement parallèle en Python : accélérez votre code
• Optimisation du code multiprocesseur en Python
• Introduction à la programmation asynchrone avec Asyncio de Python

Bon codage, et que vos programmes concurrents s’exécutent efficacement!

Explorer d’autres articles

Note

Voici d’autres articles de la même catégorie pour vous aider à approfondir le sujet.