Concurrent Futures en Python : lancer facilement des tâches parallèles

Atteindre des performances optimales grâce à une exécution parallèle est essentiel. Python, un langage de programmation polyvalent, fournit plusieurs outils pour une exécution simultanée. L'un des modules les plus puissants et les plus conviviaux est concurrent.futures, qui permet aux développeurs d'exécuter des appels de manière asynchrone. Dans cet article, nous explorerons les fonctionnalités de ce module et comment l'exploiter pour diverses tâches, notamment les opérations sur les fichiers et les requêtes Web.

Aperçu des contrats à terme simultanés

Le module concurrent.futures propose une classe abstraite appelée Executor, qui facilite l'exécution des appels de manière asynchrone. Bien qu'il ne doive pas être utilisé directement, les développeurs peuvent utiliser ses sous-classes concrètes, telles que ThreadPoolExecutor et ProcessPoolExecutor, pour effectuer des tâches simultanément.

Principales fonctionnalités

1. Méthode de soumission : La méthode de soumission est l'endroit où la magie opère. Il planifie l'exécution d'une fonction appelable de manière asynchrone et renvoie un objet Future. L'appelable est exécuté avec les arguments fournis, permettant aux développeurs d'exécuter des tâches en arrière-plan de manière transparente.

   with ThreadPoolExecutor(max_workers=1) as executor:
       future = executor.submit(pow, 323, 1235)
       print(future.result())

Dans cet exemple, nous utilisons un ThreadPoolExecutor pour élever un nombre à une puissance dans un thread séparé.

1. Méthode Map : La méthode map est une autre fonctionnalité fantastique qui permet d'exécuter une fonction sur plusieurs itérables d'entrée simultanément. Il collecte les itérables immédiatement et exécute les appels de manière asynchrone.

   results = executor.map(load_url, URLS, timeout=2)

Cette fonctionnalité est particulièrement utile lorsque vous disposez d'une liste de tâches que vous souhaitez exécuter en parallèle.

Application pratique : copie de fichiers

Envisagez un scénario dans lequel vous devez copier plusieurs fichiers efficacement. L'extrait de code suivant montre comment utiliser un ThreadPoolExecutor pour copier des fichiers simultanément :

import concurrent.futures
import shutil

files_to_copy = [
    ('src2.txt', 'dest2.txt'),
    ('src3.txt', 'dest3.txt'),
    ('src4.txt', 'dest4.txt'),
]

with concurrent.futures.ThreadPoolExecutor() as executor:
    futures = [executor.submit(shutil.copy, src, dst) for src, dst in files_to_copy]
    for future in concurrent.futures.as_completed(futures):
        print(future.result())

Cet exemple exploite la fonction shutdown.copy pour effectuer des copies de fichiers en parallèle, améliorant ainsi considérablement les performances des opérations sur les fichiers à grande échelle.

Gestion simultanée des requêtes Web

Une autre application intéressante du module concurrent.futures consiste à récupérer le contenu de plusieurs URL à la fois. Vous trouverez ci-dessous une implémentation simple utilisant ThreadPoolExecutor pour récupérer des pages Web :

import concurrent.futures
import urllib.request

URLS = [
    'http://www.foxnews.com/',
    'http://www.cnn.com/',
    'http://europe.wsj.com/',
    'http://www.bbc.co.uk/',
    'http://nonexistant-subdomain.python.org/',
]

def load_url(url, timeout):
    with urllib.request.urlopen(url, timeout=timeout) as conn:
        return conn.read()

with concurrent.futures.ThreadPoolExecutor() as executor:
    results = executor.map(load_url, URLS, timeout=2)
    for result in results:
        print(result)

Ce code est un moyen simple de récupérer rapidement du contenu Web, démontrant à quel point il est facile de mettre en œuvre une exécution simultanée dans vos projets.

Conclusion

Le module concurrent.futures fournit un moyen puissant d'exécuter des tâches de manière asynchrone en Python, simplifiant ainsi le processus de réalisation du parallélisme dans vos applications. Grâce à sa classe Executor et à ses méthodes telles que submit et map, les développeurs peuvent gérer efficacement les tâches en arrière-plan, qu'elles impliquent des opérations sur les fichiers, des requêtes Web ou tout autre processus lié aux E/S.

En intégrant ces techniques dans vos pratiques de programmation, vous serez en mesure de créer des applications plus réactives et efficaces, améliorant à la fois les performances et l'expérience utilisateur. Bon codage !

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!