¿Qué es y cómo funciona el import multiprocessing en Python?

Cuando empecé a trabajar con proyectos más complejos en Python me encontré con una necesidad, la de optimizar la ejecución de mis programas para hacerlos rendir de la m mejor manera posible. Ya sea que necesite procesar cantidades bastante elevadas de datos o realizar cálculos difíciles, podemos aprovechar los recursos de neustra CPU de un excelente modo por medio del import multiprocessing, la forma en la que importamos el módulo multiprocessing. El día de hoy quiero contarte qué es y cómo funciona.

¿Qué es el módulo de import multiprocessing?

El multiprocessing en python es un módulo diseñado para realizar paralelismo basado en procesos. Se diferencia de los hilos porque estos están limitados por el Global Interpreter Lock o GIL, en cambio el módulo de import multiprocessing crea los procesos de manera independiente, cada uno posee su intérprete y espacio en memoria. Esto indica que es posible aprovechar los múltiples núcleos de nuestra CPU de una manera mucho más eficiente.

El import multiprocessing es la manera en la que se importa este módulo dentro de Python. Cuando usamos import multiprocessing, podemos realizar tareas como lo son:

• Crear y gestionar procesos.
• Establecer comunicación y sincronización entre procesos.
• Aprovechar pools de procesos para ejecutar tareas en paralelo.

En pocas palabras, este módulo nos permite diseñar aplicaciones más rápidas y eficientes sin las limitaciones del GIL.

¿Cómo funciona import multiprocessing?

El import multiprocessing es versátil y ofrece algunas formas para su trabajo, veamos cómo podemos hacer que funcione de forma óptima:

• Creación de procesos con Process: este es el componente má sbásico del import multiprocessing y se utiliza para crear nuevos procesos. Cada uno de los procesos se inicia al llamar al método start y se detiene cuando completa su tarea. Veamos un ejemplo:

from multiprocessing import Process

def saludar(nombre):
    print(f"Hola, {nombre}")

if __name__ == "__main__":
    proceso = Process(target=saludar, args=("Carlos",))
    proceso.start()
    proceso.join()

Para este ejmplo hemos creado un proceso que ejecuta la función saludar con un argumento. El método join asegura que el proceso principal espere a que el proceso hijo termine antes de continuar.

• Comunicación entre procesos: debido a que los proceso en import multiprocessing tienen memoria independiente, se requieren herramientas específicas para compartir información entre ellos. Los más comunes son queue y pipe. Veamos cómo funciona cada uno:
  • Queue: Una cola que permite a los procesos pasar mensajes de manera segura.
  • Pipe: Un canal de comunicación simple que conecta dos procesos.

Veamos un ejemplo con queue:

from multiprocessing import Process, Queue

def enviar_mensaje(cola):
    cola.put("Mensaje desde el proceso hijo")

if __name__ == "__main__":
    cola = Queue()
    proceso = Process(target=enviar_mensaje, args=(cola,))
    proceso.start()
    print(cola.get())  # Recupera el mensaje
    proceso.join()

Este ejemplo demuestra cómo un proceso puede enviar datos al proceso principal utilizando una cola.

• Pools de procesos: si necesitas ejecutar la misma tarea de manera reiterativa en diferentes datos, pool es lo que te facilita el trabajo, ya que administra de forma automática un grupo de procesos para ejecutar tareas en paralelo:

from multiprocessing import Pool

def cuadrado(n):
    return n * n

if __name__ == "__main__":
    with Pool(processes=4) as pool:
        numeros = [1, 2, 3, 4, 5]
        resultados = pool.map(cuadrado, numeros)
        print(resultados)

En este caso, la función cuadrado se aplica en paralelo a cada elemento de la lista numeros, utilizando 4 procesos.

• Sincronización entre procesos: existen situaciones en donde múltiples procesos necesitan acceder a un recurso compartido, para ello puedes usar herramientas como Lock para garantizar que un solo proceso sea el que acceda a un recurso a l avez. Veamos un ejemplo:

from multiprocessing import Process, Lock

def imprimir(lock, mensaje):
    with lock:
        print(mensaje)

if __name__ == "__main__":
    lock = Lock()
    procesos = [
        Process(target=imprimir, args=(lock, f"Mensaje {i}"))
        for i in range(5)
    ]
    for p in procesos:
        p.start()
    for p in procesos:
        p.join()

Este ejemplo muestra cómo evitar conflictos al imprimir mensajes desde varios procesos.

Métodos de inicio

Dependiendo de tu sistema operativo, import multiprocessing ofrece tres métodos para iniciar procesos:

• spawn: Crea un nuevo intérprete de Python. Es el método por defecto en Windows y macOS.
• fork: Copia el proceso principal. Solo disponible en sistemas Unix.
• forkserver: Inicia un servidor que genera nuevos procesos bajo demanda. Ideal para aplicaciones que necesitan procesos aislados.

Puedes seleccionar el método que prefieras usando set_start_method al comienzo del programa.

Algunas recomendaciones finales para su uso

1. Usa if name == “main”: En sistemas como Windows y macOS, es obligatorio proteger la creación de procesos dentro de este bloque para evitar errores.
2. Evita el estado global compartido: Usa estructuras como Queue, Pipe o Manager para compartir datos de manera segura.
3. Termina procesos correctamente: Evita usar terminate a menos que sea absolutamente necesario, ya que puede dejar recursos en un estado inconsistente.
4. Elige el método de inicio adecuado: spawn es el más seguro en términos de compatibilidad, pero fork puede ser más rápido en Unix.

Si quires seguir aprendiendo sobre estas temáticas y similares, únete a nuestro bootcamp en programación inicial, con el cual aprenderás todo lo necesario para incursionar en el mercado laboral de tus sueños y empezar a laborar en lugares excelentes. ¡No te quedes atrás con tu formación e inicia ahora!