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 32 de 47 · Concurrencia: hilos, procesos y async ✦ WebMCP implementado

Por qué PHP no usa async y Python sí

9 min de lectura 3 retos

PHP atiende cada petición en su propio proceso y no necesita async. Python suele ser un solo programa que no se apaga y atiende a mucha gente a la vez, y para eso usa un bucle de eventos. En esta lección ves por qué son dos mundos distintos, qué es esperar de verdad y cómo suena async/await antes de escribirlo.

¿De dónde vienen los nombres?

async = inglés asynchronous (asíncrono, «no al mismo ritmo»)
Marca una función que puede pararse a esperar y dejar que otra trabaje mientras tanto. Opuesto: síncrono, todo uno detrás de otro.
await = inglés await (esperar)
«Espero aquí a que esto termine, y mientras, que el bucle atienda a otros.» Solo se puede escribir dentro de una función async.
asyncio = async + IO (input/output, entrada/salida)
El módulo de la biblioteca estándar que trae el bucle de eventos y las herramientas para esperar muchas cosas a la vez.
corrutina (coroutine) = co- (junto) + rutina (función)
Una función que coopera: en vez de ejecutarse de golpe, se puede pausar y reanudar. Cada async def crea una.
bucle de eventos (event loop) = inglés event loop
El «cocinero» que va mirando qué cosa ya está lista (llegó una respuesta, pasó el tiempo) y reanuda a quien la esperaba.
En 4 ideas
1/4

PHP clásico (nginx + php-fpm) arranca un proceso por petición, cada una aislada de las demás, y es el servidor quien reparte el trabajo. Por eso tu código PHP nunca se preocupa de «hacer varias cosas a la vez».

1 · PHP: una cocina nueva por cada pedido

Piensa en un restaurante donde, por cada pedido, se abre una cocina nueva, con su cocinero, sus ollas y sus ingredientes. El cocinero hace el plato, lo entrega y la cocina se cierra y se limpia. Así trabaja PHP clásico:

  1. nginx recibe la petición del navegador y se la pasa a php-fpm.
  2. php-fpm tiene un grupo de procesos (los workers) esperando. Coge uno libre y le da la petición.
  3. Ese proceso ejecuta tu script de arriba abajo, devuelve la página y se olvida de todo: las variables desaparecen.
  4. Si llegan 50 peticiones a la vez, hay 50 procesos distintos (hasta el tope que configures), cada uno en su mundo.

La ventaja es enorme: ninguna petición puede estropear a otra. Si tu código tiene un bucle infinito o una fuga de memoria, solo se ve afectada esa petición. Y tú escribes código simple, de arriba abajo, sin pensar en nadie más.

2 · Lo lento casi nunca es calcular: es esperar

Una petición típica pasa casi todo su tiempo esperando: a que la base de datos conteste, a que otra API responda, a que el disco lea un fichero. Eso se llama E/S (entrada/salida, I/O). Mientras espera, el procesador no hace nada: es el cocinero mirando una olla a que hierva el agua.

En PHP da igual, porque mientras ese proceso espera, otros procesos atienden a otros clientes. Pero imagina un programa Python que es un solo proceso y debe atender a cientos de conexiones. Si se queda parado esperando a una, las demás esperan también.

La solución es no esperar parado: mientras una cosa tarda, atiendo otra. En código, con dos tareas que tardan un rato:

Pythonmain.py
import asyncio


async def descarga(titulo, segundos):
    print(f"empieza {titulo}")
    await asyncio.sleep(segundos)
    print(f"termina {titulo}")


async def main():
    print("-- una detrás de otra --")
    await descarga("A", 0.03)
    await descarga("B", 0.01)

    print("-- a la vez --")
    await asyncio.gather(descarga("C", 0.05), descarga("D", 0.01))


asyncio.run(main())

Mira la segunda parte: D empieza antes de que termine C y termina primero porque tarda menos. Nadie ha creado un proceso nuevo: hay un solo programa que, mientras C espera, aprovecha para arrancar D.

3 · El bucle de eventos: un cocinero con muchas ollas

Ahora cambia la imagen. En vez de una cocina por pedido, hay una sola cocina con un solo cocinero y muchas ollas. El cocinero remueve una olla, y en cuanto toca esperar (que hierva, que se haga), pasa a la siguiente. Cuando una olla está lista, vuelve a ella. Ese cocinero es el bucle de eventos.

Un bucle de eventos no es magia: es un while que reparte turnos. Esta versión casera usa generadores (módulo 07): cada yield significa «ya me toca esperar, pasa al siguiente».

Pythonmain.py
def tarea(nombre, pasos):
    for paso in range(1, pasos + 1):
        print(f"{nombre}: paso {paso}")
        yield


def bucle(tareas):
    while tareas:
        for t in list(tareas):
            try:
                next(t)
            except StopIteration:
                tareas.remove(t)


bucle([tarea("pan", 2), tarea("banco", 3)])

Las dos tareas se intercalan aunque solo hay un cocinero. Una corrutina de asyncio hace lo mismo que ese yield, pero con await. Aquí está lo que pasa de verdad, comparado con PHP:

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

$tareaA = new Fiber(function (): void {
    echo "A: empiezo" . PHP_EOL;
    Fiber::suspend();
    echo "A: termino" . PHP_EOL;
});
$tareaB = new Fiber(function (): void {
    echo "B: empiezo" . PHP_EOL;
    Fiber::suspend();
    echo "B: termino" . PHP_EOL;
});

$tareaA->start();
$tareaB->start();
$tareaA->resume();
$tareaB->resume();
Pythonmain.py
import asyncio


async def tarea(nombre):
    print(f"{nombre}: empiezo")
    await asyncio.sleep(0)
    print(f"{nombre}: termino")


async def main():
    await asyncio.gather(tarea("A"), tarea("B"))


asyncio.run(main())
  1. Las dos salidas son idénticas: A empiezo, B empiezo, A termino, B termino.
  2. Un Fiber de PHP 8.1 es una función que se puede pausar (Fiber::suspend()) y reanudar (resume()), igual que una corrutina.
  3. La diferencia: en PHP los reanudas tú, a mano, uno por uno. En Python, asyncio.run trae el bucle que lo hace por ti, y asyncio.sleep(0) significa «pasa el turno».

4 · Entonces, ¿por qué PHP no lo necesita y Python sí?

¿Por qué? · En PHP no existe

¿Por qué Python usa async y PHP casi no? En PHP no existe de serie

Es una cuestión de cómo vive el programa, no de que un lenguaje sea mejor:

  • PHP muere al terminar la petición. Si algo tarda, ese proceso espera, y el resto del servidor sigue vivo. El que reparte es nginx + php-fpm. Y como el proceso empieza limpio cada vez, nadie comparte memoria con nadie: no hay carreras ni cerrojos.
  • Python suele quedarse encendido. Un servidor como FastAPI + uvicorn (módulo 09) arranca una vez y atiende miles de peticiones dentro del mismo proceso. Si una petición se bloquea esperando la base de datos y no hay bucle de eventos, todas se quedan paradas.
  • Crear un proceso por conexión sale caro (memoria y tiempo de arranque). Con 10 000 conexiones abiertas, no quieres 10 000 procesos; quieres un cocinero listo que pase de una olla a otra.

El fallo que evita: un programa que, por esperar a una sola conexión lenta, deja sin servicio a todas las demás.

#PreguntaPHP clásico (php-fpm)Python con asyncio
1¿Cuántos procesos?Uno por petición, creados y destruidosUno solo (o pocos), siempre encendido
2¿Quién reparte el trabajo?El servidor (nginx + php-fpm)El bucle de eventos, dentro de tu programa
3¿Qué pasa si esperas a la base de datos?Ese proceso espera; los demás siguenTienes que escribir await, o se para todo
4¿Comparten memoria las peticiones?No (todo se tira al acabar)Sí: el mismo programa vive entre peticiones
5¿Quién escribe la lógica de concurrencia?Nadie: viene de fábricaTú, con async/await

5 · Tres formas de hacer varias cosas a la vez

Volvemos a la cocina. Hay tres maneras de que tu programa haga varias cosas a la vez, y las tres tienen una lección en este módulo:

#CocinaEn PythonCómo se reparteLección
1Un cocinero con muchas ollasasyncio (corrutinas)Un solo hilo; cada await pasa el turnoEsta y «async/await»
2Varios cocineros en la misma cocinaHilos (threading)Comparten fuegos y despensa (memoria); el sistema los turna«Hilos y el GIL»
3Varias cocinas, una por cocineroProcesos (multiprocessing)Cada uno tiene su memoria y sus ollas; se pasan los platos por una ventanilla«multiprocessing y futures»

No son rivales: cada una gana en un caso. La última lección del módulo te dice cómo elegir. Por ahora quédate con la idea de la primera: no es hacer cosas más rápido, es no perder el tiempo esperando.

6 · La pregunta del programador web

La pregunta que te vas a hacer

Vale, pero… ¿tengo que usar async en cada función que escriba?

No. async se pega: una función async solo se puede llamar con await desde otra async, así que se extiende hacia arriba. La regla práctica: úsalo en el borde donde esperas (red, base de datos) y deja el cálculo en funciones normales. En FastAPI, de hecho, puedes mezclar funciones def y async def en el mismo proyecto; lo verás en el módulo 09.

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

Tu primera corrutina

Dentro de main, espera (con await) a la corrutina cargar("Comprar pan") e imprime lo que devuelve. Debe salir exactamente Cargada: Comprar pan. Es el equivalente a llamar a una función normal, pero con await delante.

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. PHP clásico es un proceso por petición y el servidor reparte el trabajo; Python suele ser un proceso largo que atiende muchas conexiones.
  2. Lo lento casi siempre es esperar (E/S), no calcular; mientras una cosa espera, otra puede avanzar.
  3. async def crea una corrutina; await dice «espero, atiende a otro»; asyncio.run arranca el bucle. En PHP, los Fibers son la pieza básica y ReactPHP/Amp/Swoole ponen el bucle.
  4. async ayuda cuando hay esperas, no cuando hay cálculo: no acelera una multiplicación enorme.
  5. Tres formas de hacerlo a la vez: asyncio (un cocinero, muchas ollas), hilos (varios cocineros, una cocina) y procesos (varias cocinas).

Para recordarlo: «Un cocinero no se queda mirando la olla»

Si espera, atiende a otro: eso es await. Si hay que calcular sin parar, un cocinero no basta (lección «multiprocessing y futures»). Y en PHP, el restaurante abre una cocina nueva por pedido.