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.
En una línea
Sección titulada «En una línea»Los procesos paralelizan de verdad porque no comparten nada, y por eso cada dato que cruza la frontera se paga dos veces.
La medición
Sección titulada «La medición»| 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.
El modelo
Sección titulada «El modelo»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
lambdao 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
lockno lo son. - La guardia
if __name__ == "__main__". Con los métodos de arranquespawnyforkserver, cada worker reimporta el módulo principal; sin la guardia intentaría crear su propio pool durante ese arranque y Python lo detiene con unRuntimeError(“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.spawnes el método por defecto en Windows y macOS; en Linux lo erafork, pero desde Python 3.14 el valor por defecto esforkserver, así que la guardia también hace falta allí.
Qué cuesta cruzar la frontera
Sección titulada «Qué cuesta cruzar la frontera»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.
Dónde encajan los procesos
Sección titulada «Dónde encajan los procesos»- 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: para 3.11–3.13, los procesos siguen siendo la vía. Ejecutado en 3.14.3: los dos pools dan el mismo resultado y, en esta carga, el mismo tiempo.
| Modelo | Tiempo (mejor de 3) |
|---|---|
| Serie | 1.73 s |
| 4 subintérpretes | 0.46 s |
| 4 procesos | 0.45 s |
CPython 3.14.3, Windows x64. Con otra corrida salieron 0.55 s y 0.55 s: la diferencia entre ambos está dentro del ruido. La ventaja de los subintérpretes (menos memoria por worker) no se ve en el tiempo.
py -3.14 mediciones/06-03-interpretes.py
El método de arranque por defecto en Windows es spawn, también en 3.14 (multiprocessing.get_start_method() devolvió spawn en 3.13 y 3.14). En Linux, 3.14 cambió el valor por defecto de fork a forkserver (nota de versión de 3.14); aquí no se pudo ejecutar.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- Si el trabajo es E/S. Los hilos o
asyncioson 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).
Ejercicio
Sección titulada «Ejercicio»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.
Las cuentas, para comprobarlas:
imagenes, cpu, mb, workers = 10_000, 0.2, 4, 8serie = imagenes * cpuprint(f"serie: {serie:.0f} s ({serie / 60:.0f} min)")print(f"{workers} hilos: ~{serie:.0f} s (el GIL serializa la CPU)")print(f"{workers} procesos, caso ideal: {serie / workers:.0f} s ({serie / workers / 60:.1f} min)")print(f"datos en vuelo: {workers * mb} MB; con imagenes de 100 MB: {workers * 100} MB")Referencias
Sección titulada «Referencias»- 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.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 02 · Hilos: el modelo que no paraleliza CPU.
- 04 ·
asyncio: la alternativa para miles de esperas. - 08 · Elegir modelo: la tabla de decisión.