Cómo usar concurrent.futures en Python
El módulo concurrent.futures en Python permite ejecutar tareas de manera concurrente, simplificando la ejecución de subprocesos (threads) y procesos (processes) en paralelo. Este módulo es útil para aprovechar la concurrencia en Python, especialmente en tareas que involucran operaciones de E/S o computación intensiva. Proporciona dos ejecutores (ThreadPoolExecutor y ProcessPoolExecutor) que gestionan el pool de hilos o procesos y optimizan el rendimiento de las tareas concurrentes.
¿Qué es concurrent.futures?
concurrent.futures es un módulo de Python que permite lanzar tareas de manera concurrente utilizando hilos o procesos. Funciona bien para situaciones en las que se necesita realizar varias operaciones al mismo tiempo, como operaciones de red, cálculos complejos, o múltiples operaciones de E/S.
Principales clases de concurrent.futures
1. ThreadPoolExecutor: Ejecuta tareas en un pool de hilos.
2. ProcessPoolExecutor: Ejecuta tareas en un pool de procesos, permitiendo aprovechar múltiples núcleos de CPU.
Ambas clases manejan la gestión de subprocesos o procesos y proporcionan métodos como .submit() y .map() para ejecutar funciones de forma asíncrona.
Ejemplo de uso básico de ThreadPoolExecutor
En el siguiente ejemplo, utilizaremos ThreadPoolExecutor para ejecutar múltiples tareas de forma concurrente:
from concurrent.futures import ThreadPoolExecutor
def tarea(n):
print(f"Procesando tarea {n}")
return n * 2
# Crear un pool de 5 hilos
with ThreadPoolExecutor(max_workers=5) as executor:
# Enviar tareas al pool
resultados = executor.map(tarea, range(10))
# Imprimir resultados
for resultado in resultados:
print(resultado)
Tabla de métodos principales de concurrent.futures
| Método | Descripción |
|---|---|
.submit(fn, args)
|
Envía una función fn al executor con sus argumentos para ejecutarse de forma asíncrona.
|
.map(fn, iterable)
|
Aplica la función fn a cada elemento en el iterable, ejecutándolos en paralelo.
|
.shutdown(wait=True)
|
Espera a que todas las tareas terminen y libera los recursos. |
.result()
|
Devuelve el resultado de una tarea asíncrona (usado con Future en .submit).
|
Ejemplo de uso de ProcessPoolExecutor
Para tareas computacionalmente intensivas, ProcessPoolExecutor permite ejecutar funciones en varios procesos para aprovechar todos los núcleos de la CPU.
from concurrent.futures import ProcessPoolExecutor
def calcular_cuadrado(n):
return n * n
# Crear un pool de 3 procesos
with ProcessPoolExecutor(max_workers=3) as executor:
resultados = executor.map(calcular_cuadrado, range(10))
for resultado in resultados:
print(resultado)
En este ejemplo, ProcessPoolExecutor ejecuta la función calcular_cuadrado en paralelo, maximizando el uso de CPU.
Conclusión
El módulo concurrent.futures es una herramienta eficaz para implementar concurrencia en Python, ya sea con hilos para operaciones de E/S o con procesos para tareas intensivas en CPU. Es fácil de usar y muy útil para mejorar el rendimiento en aplicaciones que requieren realizar múltiples operaciones de forma simultánea.
Para más detalles, consulta la documentación oficial de concurrent.futures.
Jorge García
Fullstack developer