Lección 36 de 47 · Concurrencia: hilos, procesos y async✦ WebMCP implementado
Hilos, procesos o async: cuál elegir
8 min de lectura3 retos
Ya conoces las tres herramientas: asyncio, hilos y procesos. Esta lección no enseña nada nuevo: te da el criterio para elegir. La pregunta que lo decide todo es una sola: ¿mi tarea espera o calcula?
¿De dónde vienen los nombres?
E/S limitada (I/O-bound) = inglés I/O bound (atado a E/S)
Una tarea cuyo tiempo se va esperando a algo de fuera: red, disco, base de datos. Cuanto más rápido sea tu procesador, no cambia nada.
CPU limitada (CPU-bound) = inglés CPU bound (atado al procesador)
Una tarea cuyo tiempo se va calculando: imágenes, hashes, estadísticas. Aquí sí manda la velocidad y el número de núcleos.
Queue = inglés queue (cola, como la del pan)
Una cola de tareas: unos meten trabajo y otros lo sacan por orden. En asyncio se usa para repartir tareas entre varios trabajadores.
run_in_executor = inglés run in executor (ejecutar en un ejecutor)
Manda una función normal a un grupo de hilos o procesos y te deja esperar su resultado con await.
En 4 ideas
1/4
La pregunta clave: ¿esta tarea espera (E/S) o calcula (CPU)? Esperar es red, disco o base de datos; calcular es procesar números o imágenes sin parar.
Espera → asyncio (muchas conexiones, un solo hilo) o hilos (código normal que bloquea). Calcula → procesos (o, en un Python sin GIL, hilos).
Se pueden mezclar: asyncio.to_thread manda lo bloqueante a un hilo y loop.run_in_executor manda lo pesado a un proceso, sin congelar el bucle.
En PHP ya lo hacías sin saberlo: php-fpm = procesos, curl_multi = E/S a la vez y un worker de colas = cálculo fuera de la petición. En Python eliges tú.
1 · La pregunta que lo decide todo
Última visita a la cocina. Tienes una tarea y tienes que decidir cuántos cocineros poner. Antes de nada, pregúntate qué hace el cocinero la mayor parte del tiempo:
Mirar una olla a que hierva (esperar a la red, al disco o a la base de datos). Poner más cocineros no la hace hervir antes; lo útil es que mientras uno espera, otro atienda: eso es E/S.
Picar cebolla sin parar (calcular). Aquí no hay nada que esperar; para ir más rápido necesitas más manos trabajando a la vez: eso es CPU.
#
Tu tarea…
Tipo
Mejor opción en Python
Por qué
1
Pedir 200 páginas a una API
E/S
asyncio con gather (y Semaphore)
Mucha espera, un solo hilo sobra
2
Leer ficheros o consultar con una biblioteca que no es async
E/S
Hilos (ThreadPoolExecutor, to_thread)
El código bloquea, pero cada hilo suelta el GIL al esperar
3
Redimensionar 500 fotos, hashear, comprimir
CPU
Procesos (ProcessPoolExecutor)
Cada proceso tiene su GIL y su núcleo
4
Una cuenta enorme con matrices
CPU
NumPy (ya paraleliza por dentro) o procesos
La parte pesada ya va en C, sin GIL
5
Un servidor web con miles de conexiones
E/S
asyncio (FastAPI + uvicorn)
Un cocinero con miles de ollas
2 · La misma tarea de espera, con hilos y con asyncio
Para ver que la diferencia está en cómo se escribe, aquí va la misma tarea (esperar un poco y devolver el título en mayúsculas) con hilos y con asyncio:
Pythonmain.pySolo lectura: necesita hilos del sistema
import asyncio
import time
from concurrent.futures importThreadPoolExecutordefespera(titulo):
time.sleep(0.02)
return titulo.upper()
titulos = ["pan", "banco", "python"]
withThreadPoolExecutor(max_workers=3) as pool:
print(list(pool.map(espera, titulos)))
asyncdefespera_async(titulo):
await asyncio.sleep(0.02)
return titulo.upper()
asyncdefmain():
print(await asyncio.gather(*(espera_async(t) for t in titulos)))
asyncio.run(main())
Mismo resultado. Con hilos escribes código normal (def, time.sleep) y el sistema reparte los turnos. Es lo más fácil de adoptar.
Con asyncio necesitas async def y await en todo el camino, pero un solo hilo atiende miles de esperas sin pagar un hilo por cada una (cada hilo gasta memoria).
Con procesos (para CPU) la receta es la de la lección «multiprocessing y futures»: ProcessPoolExecutor, funciones de nivel superior y if __name__ == "__main__":.
Y en PHP, ¿cómo se hacía lo mismo? Con curl_multi: PHP ya sabía hacer E/S a la vez desde mucho antes de los Fibers. Es la misma idea (un solo proceso esperando varias cosas), escrita a mano:
import asyncio
# Simulamos la red con asyncio.sleep; en la vida real usarías httpxasyncdefdescarga(url):
await asyncio.sleep(0.01)
return"contenido de " + url
asyncdefmain():
urls = ["https://example.com/a", "https://example.com/b"]
cuerpos = await asyncio.gather(*(descarga(url) for url in urls))
for cuerpo in cuerpos:
print(len(cuerpo))
asyncio.run(main())
PHP: creas un «multi», le añades un manejador por URL y haces un bucle curl_multi_exec + curl_multi_select hasta que no queden activos. El bucle de eventos lo escribes tú.
Python: gather y listo; el bucle viene dentro de asyncio.
La salida (el tamaño de cada respuesta) depende de la red en PHP; aquí la simulamos para que el ejemplo salga siempre igual.
3 · Mezclar: lo bloqueante y lo pesado, fuera del bucle
Un programa real casi nunca es de un solo tipo. Un servidor asyncio puede recibir una petición que pida calcular un informe pesado. Si lo calculas en una corrutina, congelas el bucle para todos (lección anterior). La salida es mandar el cálculo fuera:
Pythonmain.pySolo lectura: necesita procesos del sistema
import asyncio
from concurrent.futures importProcessPoolExecutordefpesada(n):
returnsum(i * i for i inrange(n))
asyncdefmain():
bucle = asyncio.get_running_loop()
withProcessPoolExecutor(max_workers=2) as pool:
resultados = await asyncio.gather(
bucle.run_in_executor(pool, pesada, 100),
bucle.run_in_executor(pool, pesada, 1000),
)
print(resultados)
if __name__ == "__main__":
asyncio.run(main())
$ python main.py
[328350, 332833500]
asyncio.get_running_loop() te da el bucle que está corriendo.
run_in_executor(pool, funcion, argumento) manda la función a un grupo de procesos (o de hilos si pasas un ThreadPoolExecutor) y devuelve algo que se puede esperar con await.
Mientras el cálculo trabaja en otro proceso, el bucle sigue atendiendo a los demás.
Para lo bloqueante ligero, asyncio.to_thread hace lo mismo con un hilo y menos escritura (lo viste en la lección anterior).
El patrón más repetido para E/S es la cola con trabajadores: unos meten tareas en una asyncio.Queue y varios trabajadores las van sacando. Este tiene un solo trabajador:
Pythonmain.py
import asyncio
asyncdeftrabajador(cola, hechas):
whileTrue:
titulo = await cola.get()
hechas.append(titulo.upper())
cola.task_done()
asyncdefmain():
cola = asyncio.Queue()
hechas = []
trabajo = asyncio.create_task(trabajador(cola, hechas))
for titulo in ["pan", "banco", "python"]:
cola.put_nowait(titulo)
await cola.join()
trabajo.cancel()
print(hechas)
asyncio.run(main())
put_nowait mete una tarea sin esperar; get() saca una (y espera si no hay).
task_done() avisa de que esa tarea está terminada; await cola.join() espera a que todas lo estén.
El trabajador es un while True, así que al final se cancela con trabajo.cancel(). El reto de esta lección amplía esto a varios trabajadores.
4 · ¿Por qué no uso siempre lo mismo?
¿Por qué? · En PHP no existe
¿Por qué no elegir una sola herramienta para todo? En PHP no existe
Porque cada una cobra un peaje distinto:
asyncio: es lo más barato en memoria, pero todo el camino tiene que ser async, y un solo cálculo largo o un time.sleep congela a todos.
Hilos: aceptan código normal que bloquea, pero cada uno gasta memoria, hay que proteger los datos compartidos con Lock y, con GIL, no aceleran el cálculo.
Procesos: aceleran el cálculo de verdad, pero arrancar uno es caro, los datos viajan copiados y no se comparte nada.
En PHP te ahorrabas esta decisión: php-fpm elegía procesos por ti. En Python, el mismo programa puede ser un script, una API con miles de conexiones o un cálculo científico, y por eso tienes que decidirlo tú.
#
Herramienta
Gana cuando…
Pierde cuando…
1
asyncio
Hay miles de esperas a la vez
Hay cálculo pesado o bibliotecas que bloquean
2
Hilos
Quieres E/S concurrente sin reescribir el código a async
Calculas (por el GIL) o compartes muchos datos
3
Procesos
Calculas en varios núcleos
La tarea es pequeña o tienes que mandar muchos datos
5 · En nuestra app de tareas
Veamos dónde caería cada cosa de la app de tareas. Este programa clasifica tareas reales del proyecto con una tabla de decisión y dice qué herramienta toca:
Pythonmain.py
ELECCION = {
"espera": "asyncio (o hilos)",
"calculo": "procesos",
}
tareas_de_la_app = [
("consultar tareas en SQLite", "espera"),
("avisar por correo de un vencimiento", "espera"),
("pedir el clima a una API externa", "espera"),
("exportar 100.000 tareas a un PDF", "calculo"),
("calcular estadísticas de un año", "calculo"),
]
for descripcion, tipo in tareas_de_la_app:
print(f"{descripcion}: {ELECCION[tipo]}")
Hora de practicar
Retos · 0/3 resueltos
Reto 1 de 3 · ✓ Resuelto
¿Cuántas esperan y cuántas calculan?
Tienes la lista tareas con tuplas (descripción, tipo), donde tipo es "espera" o "calculo". Haz que el programa imprima exactamente esperas: 3 · calculos: 2 contando cada tipo.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.sum(1 for _, tipo in tareas if tipo == "espera") cuenta las de espera. Haz lo mismo con calculo e imprime con una f-string.
Reto 2 de 3 · ✓ Resuelto
Elige la herramienta
Escribe elige(tipo). Si el tipo es una espera ("red", "disco" o "bd") devuelve "async"; si es cálculo ("calculo", "imagen" o "hash") devuelve "procesos". Para cualquier otro tipo lanza ValueError. Es la decisión de la tabla de esta lección escrita en código.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.if tipo in ("red", "disco", "bd"): devuelve "async"; haz otro if para los de cálculo y, al final, raise ValueError(...).
Reto 3 de 3 · ✓ Resuelto
Una cola con varios trabajadores
Escribe procesa_cola(titulos, trabajadores). Crea una asyncio.Queue, mete en ella todos los títulos y lanza trabajadores tareas que van sacando títulos, los pasan a mayúsculas y los guardan. Cuando la cola esté vacía (await cola.join()), cancela a los trabajadores y devuelve la lista de resultados ordenada (sorted). await procesa_cola(["pan", "banco"], 2) da ["BANCO", "PAN"].
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Crea cola = asyncio.Queue(), una función interna trabajador con while True, lanza trabajadores con create_task, mete los títulos con put_nowait, await cola.join() y cancela. Devuelve sorted(hechos).
Resumen
Lo que te llevas de esta lección
La pregunta: ¿espera o calcula? Esperar (E/S) es red, disco, base de datos; calcular (CPU) es procesar sin parar.
E/S con miles de conexiones → asyncio; E/S con código normal que bloquea → hilos; CPU → procesos (en PHP-FPM, un proceso por petición ya lo hacía).
Las tres se mezclan: asyncio.to_thread para lo bloqueante y run_in_executor con procesos para lo pesado.
Un trabajo repartido entre trabajadores es una cola (asyncio.Queue): put_nowait, get, task_done y join.
En FastAPI, async def corre en el bucle y def en un grupo de hilos: no bloquees el bucle con lo que no sea async.
Para recordarlo: «Espera: Async. Calcula: Procesos.»
EEspera red, disco, BD → asyncio o hilos
CCalcula números, imágenes → procesos
MMezcla to_thread y run_in_executor
Antes de elegir, pregunta: ¿espera o calcula? La respuesta marca la herramienta; la mezcla se hace con to_thread y run_in_executor.