ThreadPoolExecutor
Exécuter des tâches simultanément
ThreadPoolExecutor est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.
Pourquoi utiliser un pool de threads ?
Créer et joindre des threads manuellement est fastidieux. concurrent.futures.ThreadPoolExecutor gère pour vous un pool de threads workers et renvoie proprement les résultats.
from concurrent.futures import ThreadPoolExecutor
def square(n):
return n * n
with ThreadPoolExecutor() as ex:
future = ex.submit(square, 5)
print(future.result())submit et Future
submit() planifie un appel et renvoie immédiatement un Future. Vous appelez .result() dessus pour obtenir la valeur, en bloquant jusqu'à ce qu'elle soit prête.
from concurrent.futures import ThreadPoolExecutor
def greet(name):
return 'hi ' + name
with ThreadPoolExecutor(max_workers=2) as ex:
f1 = ex.submit(greet, 'Ana')
f2 = ex.submit(greet, 'Bob')
print(f1.result())
print(f2.result())map pour plusieurs entrées
executor.map(func, iterable) exécute la fonction sur chaque élément de manière concurrente et fournit les résultats dans l'ordre des entrées.
from concurrent.futures import ThreadPoolExecutor
def cube(n):
return n ** 3
with ThreadPoolExecutor() as ex:
results = ex.map(cube, range(5))
print(list(results))Contrôler le nombre de workers
max_workers limite le nombre de threads exécutés simultanément. Pour les tâches limitées par les entrées-sorties, vous pouvez utiliser plus de workers que le nombre de cœurs du processeur.
from concurrent.futures import ThreadPoolExecutor
import time
def io_task(n):
time.sleep(0.05)
return n
start = time.perf_counter()
with ThreadPoolExecutor(max_workers=4) as ex:
print(list(ex.map(io_task, range(4))))
print('ran concurrently')as_completed
as_completed(futures) fournit chaque future dès qu'elle se termine, quel que soit l'ordre de soumission. C'est idéal pour traiter les résultats dès leur arrivée.
from concurrent.futures import ThreadPoolExecutor, as_completed
import time
def work(n):
time.sleep(0.01 * (3 - n))
return n
with ThreadPoolExecutor() as ex:
futures = [ex.submit(work, i) for i in range(3)]
for f in as_completed(futures):
print('finished', f.result())Gérer les exceptions
Si une tâche déclenche une exception, celle-ci est stockée dans son Future et déclenchée de nouveau lorsque vous appelez .result(). Placez cet appel dans un bloc try/except.
from concurrent.futures import ThreadPoolExecutor
def risky(n):
if n == 0:
raise ValueError('cannot be zero')
return 10 // n
with ThreadPoolExecutor() as ex:
f = ex.submit(risky, 0)
try:
print(f.result())
except ValueError as e:
print('caught:', e)Mapper avec plusieurs arguments
map accepte plusieurs itérables et les regroupe pour les utiliser comme arguments, comme la fonction intégrée map.
from concurrent.futures import ThreadPoolExecutor
def add(a, b):
return a + b
with ThreadPoolExecutor() as ex:
print(list(ex.map(add, [1, 2, 3], [10, 20, 30])))Rassembler les résultats dans un dictionnaire
Un schéma courant consiste à associer chaque future à son entrée afin de savoir quel résultat correspond à quelle entrée lors de l'utilisation de as_completed.
from concurrent.futures import ThreadPoolExecutor, as_completed
def length(word):
return len(word)
words = ['cat', 'tiger', 'ox']
with ThreadPoolExecutor() as ex:
future_to_word = {ex.submit(length, w): w for w in words}
out = {}
for f in as_completed(future_to_word):
out[future_to_word[f]] = f.result()
print(sorted(out.items()))Arrêt avec un gestionnaire de contexte
L'utilisation de l'exécuteur dans un bloc with appelle automatiquement shutdown() et attend la fin de toutes les tâches en attente.
from concurrent.futures import ThreadPoolExecutor
def job(n):
return n * 2
with ThreadPoolExecutor() as ex:
futures = [ex.submit(job, i) for i in range(3)]
print('all tasks done after the with block')
print([f.result() for f in futures])Vérifier l'état d'un Future
Un Future expose .done() et .running(), ce qui vous permet d'inspecter la progression sans bloquer.
from concurrent.futures import ThreadPoolExecutor
def quick(n):
return n + 1
with ThreadPoolExecutor() as ex:
f = ex.submit(quick, 41)
result = f.result()
print('done?', f.done())
print('value:', result)Quand l'utiliser
ThreadPoolExecutor est idéal pour de nombreuses petites tâches limitées par les entrées-sorties : appels HTTP, lectures de fichiers et requêtes de base de données. Pour les tâches limitées par le processeur, utilisez plutôt ProcessPoolExecutor.
from concurrent.futures import ThreadPoolExecutor
urls = ['a', 'b', 'c']
def fetch(u):
return 'fetched ' + u
with ThreadPoolExecutor(max_workers=3) as ex:
for r in ex.map(fetch, urls):
print(r)Vérification rapide
Vérifiez votre compréhension de ThreadPoolExecutor.
Récapitulatif
Vous avez appris à utiliser ThreadPoolExecutor :
submit()renvoie un objet représentant un résultat futur ;map()s'exécute dans l'ordre sur un itérable.as_completed()renvoie les résultats futurs au fur et à mesure de leur achèvement.- Les exceptions apparaissent via
result(). - Le bloc
withgère l'arrêt.
Ensuite : le véritable parallélisme avec le traitement multiprocessus.
Questions Fréquemment Posées
La leçon « ThreadPoolExecutor » est-elle gratuite ?
Oui — le texte complet de « ThreadPoolExecutor » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « ThreadPoolExecutor » ?
Exécuter des tâches simultanément Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Python Academy ?
Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « ThreadPoolExecutor » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?
Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.