Saltearse al contenido

Elegir modelo

Esta parte presentó tres modelos con sus mediciones. Este capítulo es la tabla que decide, y la parte más útil es la que descarta modelos antes de escribir código.

Dos preguntas descartan dos modelos: ¿el trabajo espera o calcula? ¿cuántas cosas a la vez?

Los tres modelos, medidos en esta máquina
Escenario Serie Hilos Procesos asyncio
CPU: 4 × contar 20 M 3.93 s 3.67 s 1.28 s —
Espera: 200 × 5 ms 1.07 s 0.06 s — 0.02 s
10 000 tareas — 74.1 ms (pool) — 43.4 ms

python mediciones/06-01-08-concurrencia.py

¿El trabajo pasa la mayor parte del tiempo esperando?
├── Sí → ¿cuántas esperas simultáneas?
│ ├── Pocas (decenas) → HILOS
│ └── Miles → ASYNCIO
└── No → ¿el cálculo se puede vectorizar?
├── Sí → NUMPY (Parte V, cap. 06)
└── No → PROCESOS

Desde Python 3.14 existe una cuarta opción para CPU, los subintérpretes (InterpreterPoolExecutor, PEP 734), que no se mide aquí (hay una medición en el capítulo 03: igual que los procesos en tiempo): se parece a los procesos en el uso y con menos coste de arranque. Con 3.11–3.13, el árbol es éste.

Y dos condiciones que pueden invalidar la elección:

  • ¿Las bibliotecas son asíncronas? Si no lo son, asyncio se convierte en un pool de hilos con pasos extra. Usa hilos.
  • ¿Hay estado compartido complejo? Entonces procesos (aislados) o un diseño con colas.
Caso Modelo Por qué
API que llama a 20 servicios asyncio Miles de esperas, bibliotecas async
Procesar 10 000 imágenes Procesos CPU puro, tareas independientes
Scraper de 500 páginas Hilos o asyncio E/S de red, límite en el servidor
Cálculo numérico numpy Vectorización, no concurrencia
Servidor web asyncio (ASGI) Muchas conexiones, poca CPU por petición
Script de 10 descargas Hilos Más simple que asyncio
Nada de lo anterior Serie La concurrencia no es gratis
  • Si el programa tarda menos de un segundo. El arranque y la coordinación se comen la ganancia.
  • Si el cuello es una base de datos saturada. Más hilos empeoran la contención.
  • Si el código es correcto y suficientemente rápido. La concurrencia es deuda de mantenimiento.

Un servicio hace tres cosas por petición: consulta la base (15 ms), llama a una API externa (200 ms) y genera un PDF (400 ms de CPU). Llegan 50 peticiones por segundo. Diseña la arquitectura con los modelos de esta parte.

Solución

Cada petición consume 215 ms de espera y 400 ms de CPU. A 50 por segundo son 20 segundos de CPU por segundo: no cabe en un proceso, haga lo que haga con la concurrencia.

La arquitectura correcta separa por naturaleza:

  1. La API web, asíncrona: atiende las 50 conexiones, lanza las consultas async (base y API externa) y encola la generación del PDF. Responde 202 Accepted con un identificador.
  2. Un pool de procesos consume la cola de PDFs: 8 workers, 400 ms cada uno → 20 PDFs por segundo. Para 50 peticiones por segundo hacen falta 20 workers o acelerar la generación.
  3. El cliente consulta el estado y recoge el PDF.

Lo que no funciona: hacer el PDF dentro de la petición con asyncio (bloquea el bucle 400 ms × 50 = 20 s) ni con hilos (el GIL serializa la CPU y la cola crece).

La lección: la concurrencia no crea CPU. Cuando la carga de cálculo excede la máquina, la respuesta es encolar, escalar horizontalmente o reducir el trabajo, no cambiar de modelo.

Las cuentas, para comprobarlas:

por_segundo, espera, cpu_pdf = 50, 0.015 + 0.200, 0.400
print(f"espera por peticion: {espera * 1000:.0f} ms; CPU por peticion: {cpu_pdf * 1000:.0f} ms")
print(f"CPU por segundo de reloj: {por_segundo * cpu_pdf:.0f} s")
print(f"PDFs por segundo con 8 workers: {8 / cpu_pdf:.0f}")
print(f"workers necesarios para {por_segundo} PDFs/s: {por_segundo * cpu_pdf:.0f}")
  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 19.
  • Mediciones: mediciones/06-01-08-concurrencia.py y mediciones/06-06-07-colas-bloqueos.py.
  • 01 · El GIL: la razón de fondo de la tabla.
  • 05 · asyncio en producción: cómo se opera el modelo elegido.
  • 06 · Colas: el pegamento entre modelos.