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.
Cuándo los procesos son la respuesta
Sección titulada «Cuándo los procesos son la respuesta»- 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.
La trampa
Sección titulada «La trampa»Cuándo NO usar procesos
Sección titulada «Cuándo NO usar procesos»- 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.
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.