Saltearse al contenido

Procesos

Un proceso es otro intérprete de Python con su propio GIL. Eso resuelve el problema que los hilos no resuelven —paralelismo de CPU— y crea uno nuevo: los objetos no se comparten, se serializan. La decisión entre hilos y procesos es la decisión entre compartir memoria y compartir bytes.

Los procesos paralelizan de verdad porque no comparten nada, y por eso cada dato que cruza la frontera se paga dos veces.

Cuatro tareas de CPU (contar 20 millones, cuatro veces)
Modelo Tiempo Aceleración
Serie 3.93 s 1.00×
4 hilos 3.67 s 1.07×
4 procesos 1.28 s 3.08×

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

3,08× con cuatro workers, no 4×. La diferencia es el arranque de los procesos (en Windows, cada uno vuelve a importar el módulo) y el coste de devolver los resultados. Con tareas más grandes, la eficiencia sube; con tareas de milisegundos, el arranque se come la ganancia.

from concurrent.futures import ProcessPoolExecutor
def procesar(fila):
return transformar(fila) # tiene que ser importable
if __name__ == "__main__": # obligatorio en Windows y macOS (y en Linux desde 3.14)
with ProcessPoolExecutor(max_workers=8) as pool:
resultados = list(pool.map(procesar, filas))

Tres requisitos que no existen con hilos:

  • La función debe ser importable por nombre. Una lambda o una función definida dentro de otra no se puede enviar: se serializa por referencia.
  • Los argumentos y resultados deben ser serializables. Un objeto con una conexión abierta, un generador o un lock no lo son.
  • La guardia if __name__ == "__main__". Con los métodos de arranque spawn y forkserver, cada worker reimporta el módulo principal; sin la guardia intentaría crear su propio pool durante ese arranque y Python lo detiene con un RuntimeError (“An attempt has been made to start a new process before the current process has finished its bootstrapping phase”), no con una recursión infinita. spawn es el método por defecto en Windows y macOS; en Linux lo era fork, pero desde Python 3.14 el valor por defecto es forkserver, así que la guardia también hace falta allí.

Cada llamada serializa los argumentos con pickle, los envía por un tubo y deserializa los resultados. Para datos pequeños es despreciable; para un millón de filas puede dominar:

Dato enviado Coste aproximado
Un entero microsegundos
Una lista de 1 000 registros milisegundos
Una matriz de 100 MB segundos y memoria duplicada

La regla: manda pocos datos y grandes tareas. Si el resultado de cada tarea es pequeño y el cálculo es caro, el modelo funciona. Si cada tarea tarda menos que su serialización, no.

  • Cálculo numérico en Python puro (no numpy: sus rutinas de álgebra lineal, BLAS/LAPACK, ya usan varios hilos en C; las operaciones elemento a elemento corren en un solo hilo, y ahí los procesos sí pueden ayudar).
  • Procesamiento de imágenes o texto con tareas independientes.
  • Aislar un componente que puede caerse o consumir memoria sin arrastrar al resto.
  • Aprovechar varios núcleos cuando el trabajo es CPU y no hay una biblioteca que lo haga.

Desde Python 3.14 hay una alternativa intermedia: subintérpretes (PEP 734), con concurrent.futures.InterpreterPoolExecutor. Cada uno es un intérprete con su propio GIL dentro del mismo proceso, así que varios núcleos sin el coste de un proceso completo; los datos siguen sin compartirse libremente. Es nuevo y no está medido en este manual: para 3.11–3.13, los procesos siguen siendo la vía.

  • Si el trabajo es E/S. Los hilos o asyncio son más baratos.
  • Si los datos son grandes y las tareas pequeñas. La serialización domina.
  • Si necesitas estado compartido complejo. Ahí el diseño está pidiendo otra cosa.
  • En un contenedor con poca memoria. Cada proceso es un intérprete completo (~20 MB de base más lo que cargue).

Un pipeline procesa 10 000 imágenes: cada una tarda 200 ms en CPU (redimensionar y aplicar un filtro) y ocupa 4 MB. ¿Procesos, hilos o serie? Estima el tiempo con 8 workers y di qué límite aparece.

Solución

Serie: 10 000 × 0,2 s = 2 000 s (33 minutos). 8 hilos: ~1 900 s, porque el GIL serializa la CPU. Casi sin ganancia. 8 procesos: ~280 s (4,7 minutos), con la eficiencia algo por debajo de 8 por el arranque y la transferencia.

El límite que aparece no es la CPU: es la memoria. Ocho workers con 4 MB de imagen en vuelo son 32 MB de datos, más 8 intérpretes de Python (~200 MB). Cabe, pero si cada imagen fuera de 100 MB, ocho workers serían 800 MB y el sistema empezaría a paginar.

La mejora real: no enviar la imagen al proceso, sino la ruta, y que cada worker la lea del disco. Así sólo cruza una cadena y la imagen se carga donde se procesa.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulos 19 y 20.
  • CPython 3.13: Lib/multiprocessing/, Lib/concurrent/futures/process.py.
  • Mediciones: mediciones/06-01-08-concurrencia.py.
  • 02 · Hilos: el modelo que no paraleliza CPU.
  • 04 · asyncio: la alternativa para miles de esperas.
  • 08 · Elegir modelo: la tabla de decisión.