Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 36 de 47 · Concurrencia: hilos, procesos y async ✦ WebMCP implementado

Hilos, procesos o async: cuál elegir

8 min de lectura 3 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.

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:

  1. 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.
  2. 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…TipoMejor opción en PythonPor qué
1Pedir 200 páginas a una APIE/Sasyncio con gather (y Semaphore)Mucha espera, un solo hilo sobra
2Leer ficheros o consultar con una biblioteca que no es asyncE/SHilos (ThreadPoolExecutor, to_thread)El código bloquea, pero cada hilo suelta el GIL al esperar
3Redimensionar 500 fotos, hashear, comprimirCPUProcesos (ProcessPoolExecutor)Cada proceso tiene su GIL y su núcleo
4Una cuenta enorme con matricesCPUNumPy (ya paraleliza por dentro) o procesosLa parte pesada ya va en C, sin GIL
5Un servidor web con miles de conexionesE/Sasyncio (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 import ThreadPoolExecutor


def espera(titulo):
    time.sleep(0.02)
    return titulo.upper()


titulos = ["pan", "banco", "python"]

with ThreadPoolExecutor(max_workers=3) as pool:
    print(list(pool.map(espera, titulos)))


async def espera_async(titulo):
    await asyncio.sleep(0.02)
    return titulo.upper()


async def main():
    print(await asyncio.gather(*(espera_async(t) for t in titulos)))


asyncio.run(main())
$ python main.py
['PAN', 'BANCO', 'PYTHON']
['PAN', 'BANCO', 'PYTHON']
  1. 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.
  2. 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).
  3. 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:

PHP 8.5curl_multi.php
<?php
declare(strict_types=1);

$urls = ["https://example.com/a", "https://example.com/b"];
$multi = curl_multi_init();
$manejadores = [];

foreach ($urls as $url) {
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_multi_add_handle($multi, $ch);
    $manejadores[] = $ch;
}

do {
    $estado = curl_multi_exec($multi, $activos);
    if ($activos > 0) {
        curl_multi_select($multi);
    }
} while ($activos > 0 && $estado === CURLM_OK);

foreach ($manejadores as $ch) {
    echo strlen((string) curl_multi_getcontent($ch)) . PHP_EOL;
    curl_multi_remove_handle($multi, $ch);
}
curl_multi_close($multi);
Pythonmain.py
import asyncio


# Simulamos la red con asyncio.sleep; en la vida real usarías httpx
async def descarga(url):
    await asyncio.sleep(0.01)
    return "contenido de " + url


async def main():
    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())
  1. 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ú.
  2. Python: gather y listo; el bucle viene dentro de asyncio.
  3. 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 import ProcessPoolExecutor


def pesada(n):
    return sum(i * i for i in range(n))


async def main():
    bucle = asyncio.get_running_loop()
    with ProcessPoolExecutor(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]
  1. asyncio.get_running_loop() te da el bucle que está corriendo.
  2. 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.
  3. Mientras el cálculo trabaja en otro proceso, el bucle sigue atendiendo a los demás.
  4. 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


async def trabajador(cola, hechas):
    while True:
        titulo = await cola.get()
        hechas.append(titulo.upper())
        cola.task_done()


async def main():
    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())
  1. put_nowait mete una tarea sin esperar; get() saca una (y espera si no hay).
  2. task_done() avisa de que esa tarea está terminada; await cola.join() espera a que todas lo estén.
  3. 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ú.

#HerramientaGana cuando…Pierde cuando…
1asyncioHay miles de esperas a la vezHay cálculo pesado o bibliotecas que bloquean
2HilosQuieres E/S concurrente sin reescribir el código a asyncCalculas (por el GIL) o compartes muchos datos
3ProcesosCalculas en varios núcleosLa 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

¿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

Resumen

Lo que te llevas de esta lección

  1. La pregunta: ¿espera o calcula? Esperar (E/S) es red, disco, base de datos; calcular (CPU) es procesar sin parar.
  2. 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).
  3. Las tres se mezclan: asyncio.to_thread para lo bloqueante y run_in_executor con procesos para lo pesado.
  4. Un trabajo repartido entre trabajadores es una cola (asyncio.Queue): put_nowait, get, task_done y join.
  5. 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.