multiprocessing

multiprocessing inicia procesos hijos con intérpretes de Python separados: la forma portable de paralelizar trabajo limitado por CPU en compilaciones de Python con GIL por defecto. Comparte datos a través de colas, tuberías o multiprocessing.shared_memory.

Receta

from multiprocessing import Pool
 
def work(n: int) -> int:
    return n * n
 
if __name__ == "__main__":
    with Pool() as pool:
        print(pool.map(work, range(5)))

Cuándo usar esto:

• Bucles de Python puro con uso intensivo de CPU
• Transformaciones de datos paralelas entre núcleos
• Aislamiento de dominios de fallo (el fallo de un trabajador no mata a todos)
• Evitar el GIL para pipelines de cómputo
• Trabajos por lotes con tareas independientes

Ejemplo de funcionamiento

from multiprocessing import Process, Queue
 
def producer(q: Queue, count: int) -> None:
    for i in range(count):
        q.put(i * i)
 
def consumer(q: Queue) -> None:
    items = []
    while True:
        item = q.get()
        if item is None:
            break
        items.append(item)
    print("suma", sum(items))
 
if __name__ == "__main__":
    q: Queue = Queue()
    p = Process(target=producer, args=(q, 5))
    c = Process(target=consumer, args=(q,))
    c.start()
    p.start()
    p.join()
    q.put(None)
    c.join()

Lo que esto demuestra:

• Queue pasa objetos "picklable" entre procesos
• El centinela None termina el bucle del consumidor
• if __name__ == "__main__" es necesario para el método de inicio "spawn" (macOS, Windows)
• Los procesos no comparten objetos en memoria por defecto

Análisis detallado

Métodos de inicio

Opciones de IPC (Comunicación entre Procesos)

• Queue, Pipe para mensajes
• shared_memory para arrays grandes (3.8+)
• Preferir pasar instantáneas inmutables sobre la mutación compartida

Errores comunes

• Falta el guardián main - "spawn" recursivo al importar. Solución: if __name__ == "__main__".
• Cierres (closures) no "picklable" - el objetivo del trabajador debe ser de nivel superior o "picklable". Solución: initializer + funciones de módulo.
• "Pickling" de objetos enormes - IPC lento. Solución: memoria compartida o fragmentos respaldados por archivos.
• fork + hilos - posibles interbloqueos (deadlocks). Solución: preferir "spawn" en macOS; iniciar procesos antes que hilos.
• Sobresuscripción de Pool - memoria × trabajadores agota la RAM. Solución: maxtasksperchild y límite de trabajadores.

Alternativas

Preguntas frecuentes

Relacionado

• concurrent.futures - ProcessPoolExecutor
• El GIL y Python con Hilos Libres - por qué procesos
• Colas y Productor/Consumidor - patrones
• subprocess - comandos externos

Versiones de la pila: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.