Déverrouiller la Concurrence en Python : ThreadPoolExecutor vs. ProcessPoolExecutor

Python, bien qu'étant un langage de programmation polyvalent et largement utilisé, présente certaines limitations en matière de véritable parallélisme en raison du Global Interpreter Lock (GIL). Le module concurrent.futures fournit une interface de haut niveau pour l'exécution asynchrone de fonctions appelables, offrant un moyen de contourner certaines de ces limitations et d'améliorer les performances pour des types spécifiques de tâches. Ce module propose deux classes clés : ThreadPoolExecutor et ProcessPoolExecutor. Ce guide complet explorera les deux, en soulignant leurs différences, leurs forces et leurs faiblesses, et en fournissant des exemples pratiques pour vous aider à choisir l'exécuteur adapté à vos besoins.

Comprendre la Concurrence et le Parallélisme

Avant de plonger dans les spécificités de chaque exécuteur, il est crucial de comprendre les concepts de concurrence et de parallélisme. Ces termes sont souvent utilisés de manière interchangeable, mais ils ont des significations distinctes :

• Concurrence : Gère plusieurs tâches en même temps. Il s'agit de structurer votre code pour gérer plusieurs choses apparemment simultanément, même si elles sont en réalité entrecroisées sur un seul cœur de processeur. Pensez à un chef qui gère plusieurs casseroles sur une seule cuisinière – elles ne bouillent pas toutes au même moment, mais le chef les gère toutes.
• Parallélisme : Implique l'exécution réelle de plusieurs tâches en même temps, généralement en utilisant plusieurs cœurs de processeur. C'est comme avoir plusieurs chefs, chacun travaillant simultanément sur une partie différente du repas.

Le GIL de Python empêche largement le véritable parallélisme pour les tâches liées au CPU lors de l'utilisation de threads. En effet, le GIL ne permet qu'à un seul thread de contrôler l'interpréteur Python à un moment donné. Cependant, pour les tâches liées aux E/S, où le programme passe la majeure partie de son temps à attendre des opérations externes comme les requêtes réseau ou les lectures de disque, les threads peuvent toujours fournir des améliorations significatives des performances en permettant à d'autres threads de s'exécuter pendant qu'un seul attend.

Présentation du module `concurrent.futures`

Le module concurrent.futures simplifie le processus d'exécution des tâches de manière asynchrone. Il fournit une interface de haut niveau pour travailler avec des threads et des processus, en abstraisant une grande partie de la complexité impliquée dans leur gestion directe. Le concept de base est « l'exécuteur », qui gère l'exécution des tâches soumises. Les deux principaux exécuteurs sont :

• ThreadPoolExecutor : Utilise un pool de threads pour exécuter des tâches. Convient aux tâches liées aux E/S.
• ProcessPoolExecutor : Utilise un pool de processus pour exécuter des tâches. Convient aux tâches liées au CPU.

ThreadPoolExecutor : Tirer parti des threads pour les tâches liées aux E/S

Le ThreadPoolExecutor crée un pool de threads de travail pour exécuter des tâches. En raison du GIL, les threads ne sont pas idéaux pour les opérations intensives en calcul qui bénéficient d'un véritable parallélisme. Cependant, ils excellent dans les scénarios liés aux E/S. Explorons comment l'utiliser :

Utilisation de base

Voici un exemple simple d'utilisation de ThreadPoolExecutor pour télécharger plusieurs pages Web simultanément :

import concurrent.futures
import requests
import time

urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
    "https://www.python.org"
]


def download_page(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
        print(f"Downloaded {url}: {len(response.content)} bytes")
        return len(response.content)
    except requests.exceptions.RequestException as e:
        print(f"Error downloading {url}: {e}")
        return 0


start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # Soumettre chaque URL à l'exécuteur
    futures = [executor.submit(download_page, url) for url in urls]

    # Attendre la fin de toutes les tâches
    total_bytes = sum(future.result() for future in concurrent.futures.as_completed(futures))

print(f"Total bytes downloaded: {total_bytes}")
print(f"Time taken: {time.time() - start_time:.2f} seconds")

Explication :

1. Nous importons les modules nécessaires : concurrent.futures, requests et time.
2. Nous définissons une liste d'URL à télécharger.
3. La fonction download_page récupère le contenu d'une URL donnée. La gestion des erreurs est incluse avec `try...except` et `response.raise_for_status()` pour détecter les problèmes de réseau potentiels.
4. Nous créons un ThreadPoolExecutor avec un maximum de 4 threads de travail. L'argument max_workers contrôle le nombre maximal de threads pouvant être utilisés simultanément. Le définir trop haut peut ne pas toujours améliorer les performances, en particulier pour les tâches liées aux E/S où la bande passante réseau est souvent le goulot d'étranglement.
5. Nous utilisons une compréhension de liste pour soumettre chaque URL à l'exécuteur en utilisant executor.submit(download_page, url). Cela renvoie un objet Future pour chaque tâche.
6. La fonction concurrent.futures.as_completed(futures) renvoie un itérateur qui produit des futurs au fur et à mesure qu'ils se terminent. Cela évite d'attendre la fin de toutes les tâches avant de traiter les résultats.
7. Nous parcourons les futurs terminés et récupérons le résultat de chaque tâche en utilisant future.result(), en additionnant le total des octets téléchargés. La gestion des erreurs dans `download_page` garantit que les échecs individuels ne plantent pas l'ensemble du processus.
8. Enfin, nous imprimons le nombre total d'octets téléchargés et le temps écoulé.

Avantages de ThreadPoolExecutor

• Concurrence simplifiée : Fournit une interface claire et facile à utiliser pour la gestion des threads.
• Performances liées aux E/S : Excellent pour les tâches qui passent beaucoup de temps à attendre les opérations d'E/S, telles que les requêtes réseau, les lectures de fichiers ou les requêtes de base de données.
• Réduction des frais généraux : Les threads ont généralement des frais généraux inférieurs à ceux des processus, ce qui les rend plus efficaces pour les tâches qui impliquent des commutations de contexte fréquentes.

Limitations de ThreadPoolExecutor

• Restriction GIL : Le GIL limite le véritable parallélisme pour les tâches liées au CPU. Seul un thread peut exécuter du bytecode Python à la fois, annulant les avantages de plusieurs cœurs.
• Complexité du débogage : Le débogage des applications multithreadées peut être difficile en raison des conditions de concurrence et d'autres problèmes liés à la concurrence.

ProcessPoolExecutor : Libérer le multiprocessing pour les tâches liées au CPU

Le ProcessPoolExecutor surmonte la limitation du GIL en créant un pool de processus de travail. Chaque processus possède son propre interpréteur Python et son propre espace mémoire, ce qui permet un véritable parallélisme sur les systèmes multi-cœurs. Cela le rend idéal pour les tâches liées au CPU qui impliquent des calculs importants.

Utilisation de base

Considérez une tâche intensive en calcul comme le calcul de la somme des carrés pour une large gamme de nombres. Voici comment utiliser ProcessPoolExecutor pour paralléliser cette tâche :

import concurrent.futures
import time
import os

def sum_of_squares(start, end):
    pid = os.getpid()
    print(f"Process ID: {pid}, Calculating sum of squares from {start} to {end}")
    total = 0
    for i in range(start, end + 1):
        total += i * i
    return total


if __name__ == "__main__": #Important for avoiding recursive spawning in some environments
    start_time = time.time()
    range_size = 1000000
    num_processes = 4
    ranges = [(i * range_size + 1, (i + 1) * range_size) for i in range(num_processes)]

    with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
        futures = [executor.submit(sum_of_squares, start, end) for start, end in ranges]
        results = [future.result() for future in concurrent.futures.as_completed(futures)]

    total_sum = sum(results)
    print(f"Total sum of squares: {total_sum}")
    print(f"Time taken: {time.time() - start_time:.2f} seconds")

Explication :

1. Nous définissons une fonction sum_of_squares qui calcule la somme des carrés pour une plage de nombres donnée. Nous incluons os.getpid() pour voir quel processus exécute chaque plage.
2. Nous définissons la taille de la plage et le nombre de processus à utiliser. La liste ranges est créée pour diviser la plage de calcul totale en plus petits morceaux, un pour chaque processus.
3. Nous créons un ProcessPoolExecutor avec le nombre spécifié de processus de travail.
4. Nous soumettons chaque plage à l'exécuteur en utilisant executor.submit(sum_of_squares, start, end).
5. Nous collectons les résultats de chaque futur en utilisant future.result().
6. Nous additionnons les résultats de tous les processus pour obtenir le total final.

Remarque importante : Lors de l'utilisation de ProcessPoolExecutor, en particulier sur Windows, vous devez inclure le code qui crée l'exécuteur dans un bloc if __name__ == "__main__":. Cela empêche la création récursive de processus, ce qui peut entraîner des erreurs et un comportement inattendu. En effet, le module est réimporté dans chaque processus enfant.

Avantages de ProcessPoolExecutor

• Vrai parallélisme : Surmonte la limitation du GIL, permettant un véritable parallélisme sur les systèmes multi-cœurs pour les tâches liées au CPU.
• Performances améliorées pour les tâches liées au CPU : Des gains de performance importants peuvent être obtenus pour les opérations intensives en calcul.
• Robustesse : Si un processus se bloque, il n'entraîne pas nécessairement l'arrêt de l'ensemble du programme, car les processus sont isolés les uns des autres.

Limitations de ProcessPoolExecutor

• Frais généraux plus élevés : La création et la gestion des processus ont des frais généraux plus élevés que les threads.
• Communication inter-processus : Le partage de données entre les processus peut être plus complexe et nécessite des mécanismes de communication inter-processus (IPC), ce qui peut ajouter des frais généraux.
• Empreinte mémoire : Chaque processus possède son propre espace mémoire, ce qui peut augmenter l'empreinte mémoire globale de l'application. Le passage de grandes quantités de données entre les processus peut devenir un goulot d'étranglement.

Choisir le bon exécuteur : ThreadPoolExecutor vs. ProcessPoolExecutor

La clé pour choisir entre ThreadPoolExecutor et ProcessPoolExecutor réside dans la compréhension de la nature de vos tâches :

• Tâches liées aux E/S : Si vos tâches passent la majeure partie de leur temps à attendre des opérations d'E/S (par exemple, requêtes réseau, lectures de fichiers, requêtes de base de données), ThreadPoolExecutor est généralement le meilleur choix. Le GIL est moins un goulot d'étranglement dans ces scénarios, et les frais généraux inférieurs des threads les rendent plus efficaces.
• Tâches liées au CPU : Si vos tâches sont intensives en calcul et utilisent plusieurs cœurs, ProcessPoolExecutor est la solution. Il contourne la limitation du GIL et permet un véritable parallélisme, ce qui se traduit par des améliorations significatives des performances.

Voici un tableau résumant les principales différences :

Fonctionnalité	ThreadPoolExecutor	ProcessPoolExecutor
Modèle de concurrence	Multithreading	Multiprocessing
Impact GIL	Limité par GIL	Contourne GIL
Adapté à	Tâches liées aux E/S	Tâches liées au CPU
Frais généraux	Inférieur	Supérieur
Empreinte mémoire	Inférieure	Supérieure
Communication inter-processus	Non requise (les threads partagent la mémoire)	Requise pour le partage de données
Robustesse	Moins robuste (un plantage peut affecter l'ensemble du processus)	Plus robuste (les processus sont isolés)

Techniques avancées et considérations

Soumission de tâches avec des arguments

Les deux exécuteurs vous permettent de passer des arguments à la fonction exécutée. Ceci se fait via la méthode submit() :

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function, arg1, arg2)
    result = future.result()

Gestion des exceptions

Les exceptions levées dans la fonction exécutée ne sont pas automatiquement propagées au thread ou processus principal. Vous devez les gérer explicitement lors de la récupération du résultat du Future :

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function)
    try:
        result = future.result()
    except Exception as e:
        print(f"Une exception s'est produite : {e}")

Utilisation de `map` pour des tâches simples

Pour les tâches simples où vous souhaitez appliquer la même fonction à une séquence d'entrées, la méthode map() fournit un moyen concis de soumettre des tâches :

def square(x):
    return x * x


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

Contrôle du nombre de travailleurs

L'argument max_workers dans ThreadPoolExecutor et ProcessPoolExecutor contrôle le nombre maximal de threads ou de processus pouvant être utilisés simultanément. Choisir la bonne valeur pour max_workers est important pour les performances. Un bon point de départ est le nombre de cœurs de CPU disponibles sur votre système. Cependant, pour les tâches liées aux E/S, vous pourriez bénéficier de l'utilisation de plus de threads que de cœurs, car les threads peuvent passer à d'autres tâches tout en attendant les E/S. L'expérimentation et le profilage sont souvent nécessaires pour déterminer la valeur optimale.

Suivi de la progression

Le module concurrent.futures ne fournit pas de mécanismes intégrés pour surveiller directement la progression des tâches. Cependant, vous pouvez implémenter votre propre suivi de la progression en utilisant des rappels ou des variables partagées. Des bibliothèques comme `tqdm` peuvent être intégrées pour afficher des barres de progression.

Exemples concrets

Considérons quelques scénarios réels où ThreadPoolExecutor et ProcessPoolExecutor peuvent être appliqués efficacement :

• Web Scraping : Téléchargement et analyse de plusieurs pages Web simultanément à l'aide de ThreadPoolExecutor. Chaque thread peut gérer une page Web différente, améliorant ainsi la vitesse globale de l'extraction. Soyez attentif aux conditions d'utilisation du site Web et évitez de surcharger leurs serveurs.
• Traitement d'images : Application de filtres d'images ou de transformations à un grand ensemble d'images à l'aide de ProcessPoolExecutor. Chaque processus peut gérer une image différente, tirant parti de plusieurs cœurs pour un traitement plus rapide. Envisagez des bibliothèques comme OpenCV pour une manipulation efficace des images.
• Analyse de données : Effectuer des calculs complexes sur de grands ensembles de données à l'aide de ProcessPoolExecutor. Chaque processus peut analyser un sous-ensemble des données, réduisant ainsi le temps d'analyse global. Pandas et NumPy sont des bibliothèques populaires pour l'analyse de données en Python.
• Apprentissage automatique : Entraînement de modèles d'apprentissage automatique à l'aide de ProcessPoolExecutor. Certains algorithmes d'apprentissage automatique peuvent être parallélisés efficacement, ce qui permet de réduire les temps d'entraînement. Des bibliothèques comme scikit-learn et TensorFlow offrent une prise en charge de la parallélisation.
• Encodage vidéo : Conversion de fichiers vidéo vers différents formats à l'aide de ProcessPoolExecutor. Chaque processus peut encoder un segment vidéo différent, ce qui accélère le processus d'encodage global.

Considérations générales

Lors du développement d'applications concurrentes pour un public mondial, il est important de tenir compte des éléments suivants :

• Fuseaux horaires : Soyez attentif aux fuseaux horaires lorsque vous traitez des opérations sensibles au temps. Utilisez des bibliothèques comme pytz pour gérer les conversions de fuseaux horaires.
• Paramètres régionaux : Assurez-vous que votre application gère correctement les différents paramètres régionaux. Utilisez des bibliothèques comme locale pour formater les nombres, les dates et les devises en fonction des paramètres régionaux de l'utilisateur.
• Encodages de caractères : Utilisez Unicode (UTF-8) comme encodage de caractères par défaut pour prendre en charge un large éventail de langues.
• Internationalisation (i18n) et localisation (l10n) : Concevez votre application pour qu'elle soit facilement internationalisée et localisée. Utilisez gettext ou d'autres bibliothèques de traduction pour fournir des traductions pour différentes langues.
• Latence du réseau : Tenez compte de la latence du réseau lors de la communication avec des services distants. Mettez en œuvre des délais d'attente et une gestion des erreurs appropriés pour vous assurer que votre application est résiliente aux problèmes de réseau. L'emplacement géographique des serveurs peut affecter considérablement la latence. Envisagez d'utiliser des réseaux de diffusion de contenu (CDN) pour améliorer les performances des utilisateurs dans différentes régions.

Conclusion

Le module concurrent.futures offre un moyen puissant et pratique d'introduire la concurrence et le parallélisme dans vos applications Python. En comprenant les différences entre ThreadPoolExecutor et ProcessPoolExecutor, et en considérant attentivement la nature de vos tâches, vous pouvez améliorer considérablement les performances et la réactivité de votre code. N'oubliez pas de profiler votre code et d'expérimenter différentes configurations pour trouver les paramètres optimaux pour votre cas d'utilisation spécifique. Soyez également conscient des limites du GIL et des complexités potentielles de la programmation multithread et multiprocesseurs. Avec une planification et une mise en œuvre minutieuses, vous pouvez libérer tout le potentiel de la concurrence en Python et créer des applications robustes et évolutives pour un public mondial.