Aplicaciones de Python | Aprovechando la Multiprocesamiento para Velocidad y Eficiencia

Python Applications | Harnessing Multiprocessing for Speed and Efficiency

Introducción

Utilizando las capacidades completas de los procesadores multi-núcleo contemporáneos, la multiprocesamiento es una idea fundamental en la ciencia de la computación que permite que los programas ejecuten numerosas tareas o procesos de manera concurrente. Al separar las tareas en varios procesos, cada uno con su propio espacio de memoria, la multiprocesamiento permite que el software supere las limitaciones de rendimiento, a diferencia de las técnicas convencionales de un solo hilo. Debido a que los procesos están aislados, existe estabilidad y seguridad porque se evitan los conflictos de memoria. Especialmente para trabajos limitados por la CPU que requieren operaciones computacionales extensas, la capacidad de la multiprocesamiento para optimizar la ejecución del código es crucial. Es un cambio de juego para las aplicaciones de Python donde la velocidad y la efectividad son cruciales, como el procesamiento de datos, simulaciones científicas, procesamiento de imágenes y videos, y aprendizaje automático.

Objetivos de Aprendizaje

Obtener una comprensión sólida de la multiprocesamiento y su importancia en la utilización de los procesadores multi-núcleo modernos para mejorar el rendimiento en las aplicaciones de Python.
Aprender cómo crear, gestionar y sincronizar múltiples procesos utilizando el módulo de ‘multiprocesamiento’ de Python, permitiendo la ejecución paralela de tareas mientras se garantiza la estabilidad y la integridad de los datos.
Descubrir estrategias para optimizar el rendimiento de la multiprocesamiento, incluyendo consideraciones para la naturaleza de la tarea, la utilización de recursos y abordar la sobrecarga de comunicación, para desarrollar aplicaciones eficientes y receptivas en Python.
Multiprocesamiento

Utilizando las capacidades de los procesadores multi-núcleo contemporáneos, la multiprocesamiento es un enfoque poderoso en la programación de computadoras que permite que los programas realicen numerosas tareas o procesos de manera simultánea. La multiprocesamiento genera varios procesos, cada uno con su propio espacio de memoria, en lugar de la multiprocesamiento, que implica la ejecución de múltiples hilos dentro de un solo proceso. Este aislamiento evita que los procesos interfieran en la memoria de los demás, lo que mejora la estabilidad y la seguridad.

Este artículo fue publicado como parte del Data Science Blogathon.

Importancia de la Multiprocesamiento en la Optimización de la Ejecución de Código

Un objetivo importante en el desarrollo de software es optimizar la ejecución del código. La capacidad de procesamiento de un solo núcleo puede ser una limitación para la programación secuencial tradicional. Al permitir la asignación de tareas en varios núcleos, la multiprocesamiento supera esta limitación y aprovecha al máximo las capacidades de los procesadores contemporáneos. Como resultado, las tareas que requieren mucho procesamiento se ejecutan más rápido y con un rendimiento significativamente mejor.

Escenarios en los que la Multiprocesamiento es Beneficiosa

Tareas Limitadas por la CPU: La multiprocesamiento puede resultar en mejoras significativas de velocidad para aplicaciones que necesitan principalmente operaciones computacionales intensivas, como cálculos matemáticos sofisticados o simulaciones. Cada proceso puede llevar a cabo una parte de la computación de manera concurrente para maximizar la CPU.
Procesamiento Paralelo: La multiprocesamiento permite el manejo simultáneo de diferentes sub-tareas separadas, dividiendo muchos problemas del mundo real en partes más manejables. Esto reduce el tiempo total necesario para completar la tarea.
Procesamiento de Imágenes y Videos: Aplicar filtros, cambios y análisis a diferentes partes de los medios es un aspecto común de la manipulación de fotos y películas. Distribuir estas operaciones entre procesos mediante la multiprocesamiento mejora la eficiencia.
Simulaciones Científicas: La multiprocesamiento es ventajosa para simulaciones complejas como el plegado de proteínas o la modelización del clima. La simulación puede ejecutarse en procesos independientes, lo que proporciona resultados más rápidos.
Extracción y Rastreo Web: La multiprocesamiento puede ayudar en la extracción de información de numerosos sitios web obteniendo datos de varias fuentes de manera concurrente, reduciendo el tiempo requerido para recopilar información.
Servidores Concurrentes: La multiprocesamiento es útil al crear servidores concurrentes, donde cada proceso maneja una solicitud de cliente diferente. Esto evita que las solicitudes más lentas obstaculicen a las más rápidas.
Procesamiento por Lotes: Acelera la multiprocesamiento para la finalización de cada lote en situaciones donde las tareas deben completarse por lotes.

Comprensión de Procesos y Hilos

El logro de la concurrencia y la paralelismo depende en gran medida del uso de procesos y hilos, las unidades básicas de ejecución en un programa de computadora.

Procesos:

Un proceso es una instancia aislada de un programa de usuario. Cada proceso tiene su propio entorno de ejecución, espacio de memoria y recursos. Debido a que los procesos están segregados, no comparten memoria directamente. La comunicación entre procesos (IPC) representa uno de los mecanismos más complejos para facilitar la comunicación entre procesos. Dado su tamaño y su separación inherente, los procesos son excelentes para manejar tareas pesadas, como la ejecución de varios programas independientes.

Hilos:

Los hilos son las unidades más pequeñas de ejecución dentro de un proceso. Pueden existir múltiples hilos con los mismos recursos y memoria dentro de un solo proceso. Como comparten el mismo entorno de memoria, los hilos que se ejecutan en el mismo proceso pueden comunicarse a través de variables compartidas. En comparación con los procesos, los hilos son más ligeros y más adecuados para actividades que involucran grandes cantidades de datos compartidos y una separación ligera.

Limitaciones del Cierre Global del Intérprete (GIL) y su Impacto en la Multi-Thread

Un mutex llamado Cierre Global del Intérprete (GIL) se utiliza en CPython, la implementación de Python más popular, para sincronizar el acceso a los objetos de Python y detener la ejecución concurrente de varios hilos que ejecutan bytecode de Python dentro del mismo proceso. Esto significa que incluso en sistemas con varios núcleos, solo un hilo puede ejecutar código de Python de forma concurrente dentro de un proceso dado.

Implicaciones del GIL

Tareas Ligadas a E/S: Las operaciones ligadas a E/S, donde los hilos esperan frecuentemente recursos externos como E/S de archivos o respuestas de red, se ven afectadas de manera menos significativa por el GIL. Las acciones de bloqueo y liberación del GIL tienen un efecto comparativamente menor en el rendimiento en tales circunstancias.

Cuándo usar Hilos y Procesos en Python?

Hilos: Cuando se manejan actividades ligadas a E/S, los hilos son ventajosos cuando el software debe esperar mucho tiempo por recursos externos. Pueden funcionar en segundo plano sin interferir con el hilo principal, lo que los hace adecuados para aplicaciones que requieren interfaces de usuario receptivas.

Procesos: Para operaciones ligadas a la CPU o cuando se desea utilizar completamente múltiples núcleos de CPU, los procesos son más apropiados. La multiprocesamiento permite la ejecución paralela en varios núcleos sin las restricciones del GIL, ya que cada proceso tiene su propio GIL.

El Módulo ‘Multiprocessing’

El módulo de multiprocessing de Python es una herramienta potente para lograr concurrencia y paralelismo mediante la creación y administración de varios procesos. Ofrece una interfaz de alto nivel para iniciar y administrar procesos, lo que permite a los programadores ejecutar actividades paralelas en máquinas multinúcleo.

Habilitar la Ejecución Concurrente a Través de Múltiples Procesos:

Al establecer varios procesos distintos, cada uno con su propio intérprete de Python y espacio de memoria, el módulo de multiprocessing permite ejecutar múltiples programas a la vez. Como resultado, es posible lograr una ejecución paralela real en plataformas multinúcleo al superar las restricciones del Cierre Global del Intérprete (GIL) del módulo de hilos predeterminado.

Resumen de las Clases y Funciones Principales

Clase Process:

La clase Process sirve como el cerebro del módulo de multiprocessing. Puede construir y administrar un proceso independiente utilizando esta clase, que representa uno. Las técnicas y características esenciales incluyen:

Start(): Inicia el proceso, lo que hace que la función objetivo se ejecute en un nuevo proceso.

Terminate(): Termina el proceso de manera forzada.

Clase Queue: La clase Queue ofrece un método seguro de comunicación entre procesos a través de una cola sincronizada. Se admiten operaciones de agregar y eliminar elementos de la cola mediante métodos como put() y get().

Clase Pool: La Clase Pool permite paralelizar la ejecución de una función en varios valores de entrada gracias al control de un grupo de procesos trabajadores. Las técnicas fundamentales incluyen:

Pool(processes): Constructor para crear un grupo de procesos con un número especificado de procesos trabajadores.

Clase Lock: Cuando muchos procesos utilizan el mismo recurso compartido, se pueden evitar situaciones de carrera utilizando la clase Lock para implementar la exclusión mutua.

Clases Value y Array: Estas clases te permiten crear objetos compartidos que otros procesos pueden utilizar. Útiles para transferir datos de manera segura entre procesos.

Clase Manager: Múltiples procesos pueden acceder a objetos y estructuras de datos compartidos creados utilizando la clase Manager. Proporciona abstracciones más complejas como espacios de nombres, diccionarios y listas.

Función Pipe:

La función Pipe() construye un par de objetos de conexión para la comunicación bidireccional entre procesos.

Puedes identificar el proceso en ejecución utilizando el objeto actual que devuelve esta función.

Devuelve el número de núcleos de CPU disponibles, lo que es útil para determinar cuántas tareas ejecutar simultáneamente.

Creando Procesos Usando la Clase Process

Puedes construir y controlar diferentes procesos en Python utilizando la clase Process del paquete multiprocessing. Aquí tienes una explicación paso a paso de cómo establecer procesos usando la clase Process y cómo proporcionar la función para ejecutar en un nuevo proceso utilizando el parámetro target:

import multiprocessing

# Ejemplo de función que se ejecutará en el nuevo proceso
def worker_function(numero):
    print(f"El proceso trabajador {numero} está en ejecución")

if __name__ == "__main__":
    # Crear una lista de procesos
    procesos = []

    num_procesos = 4

    for i in range(num_procesos):
        # Crear un nuevo proceso, especificando la función objetivo y sus argumentos
        proceso = multiprocessing.Process(target=worker_function, args=(i,))
        procesos.append(proceso)
        proceso.start()  # Iniciar el proceso

    # Esperar a que todos los procesos terminen
    for proceso in procesos:
        proceso.join()

    print("Todos los procesos han terminado")

El proceso trabajador 0 está en ejecución.

El proceso trabajador 1 está en ejecución.

El proceso trabajador 2 está en ejecución.

El proceso trabajador 3 está en ejecución.

Todos los procesos han terminado.

Comunicación entre Procesos

En un entorno de múltiples procesos, los procesos pueden sincronizar sus operaciones y compartir datos utilizando diversas técnicas y procedimientos conocidos como comunicación entre procesos (IPC, por sus siglas en inglés). La comunicación es crucial en un entorno de multiprocesamiento, donde numerosos procesos operan simultáneamente. Esto permite que los procesos cooperen, compartan información y planifiquen sus operaciones.

Métodos para IPC

Pipes:

Los datos pasan entre dos procesos utilizando la estructura básica de IPC conocida como pipes. Mientras que el otro proceso lee del pipe, el primer proceso escribe datos. Los pipes pueden ser nombrados o anónimos. Sin embargo, los pipes solo se pueden usar para que dos procesos distintos se comuniquen entre sí.

Colas:

Las colas del módulo multiprocessing ofrecen un método de IPC más flexible. Al enviar mensajes a través de la cola, permiten la comunicación entre numerosos procesos. El proceso transmisor agrega mensajes a la cola y el proceso receptor los recupera. La integridad de los datos y la sincronización se manejan automáticamente a través de las colas.

Memoria Compartida:

Múltiples procesos pueden acceder a la misma área gracias a la memoria compartida, facilitando el intercambio y la comunicación efectiva de datos. Controlar la memoria compartida requiere una sincronización precisa para evitar situaciones de carrera y garantizar la consistencia de los datos.

Uso de Colas para la Comunicación

Debido a su simplicidad y sincronización incorporada, las colas son una técnica de IPC popular en el módulo multiprocessing de Python. Aquí tienes una ilustración de cómo usar colas para la comunicación entre procesos:

import multiprocessing

# Función trabajadora que añade datos a la cola
def productor(cola):
    for i in range(5):
        cola.put(i)
        print(f"Producido: {i}")

# Función trabajadora que recupera datos de la cola
def consumidor(cola):
    while True:
        dato = cola.get()
        if dato is None:  # Valor centinela para detener el bucle
            break
        print(f"Consumido: {dato}")

if __name__ == "__main__":
    # Crear una cola para la comunicación
    cola = multiprocessing.Queue()

    # Crear los procesos productor y consumidor
    proceso_productor = multiprocessing.Process(target=productor, args=(cola,))
    proceso_consumidor = multiprocessing.Process(target=consumidor, args=(cola,))

    # Iniciar los procesos
    proceso_productor.start()
    proceso_consumidor.start()

    # Esperar a que el productor termine
    proceso_productor.join()

    # Indicar al consumidor que se detenga añadiendo un valor centinela a la cola
    cola.put(None)

    # Esperar a que el consumidor termine
    proceso_consumidor.join()

    print("Todos los procesos han terminado")

En este ejemplo, el proceso productor utiliza el método put() para agregar datos a la cola. El proceso consumidor recupera datos de la cola utilizando el método get(). Una vez que el productor ha terminado, se aconseja al consumidor que se detenga utilizando un valor centinela (None). La espera a que ambos procesos terminen se realiza utilizando la función join(). Esto ejemplifica cómo las colas ofrecen a los procesos un método práctico y seguro para intercambiar datos sin necesidad de técnicas explícitas de sincronización.

Paralelismo con Pooling

Puede paralelizar la ejecución de una función en varios valores de entrada utilizando la clase Pool en el módulo multiprocessing, que es una herramienta útil para gestionar un conjunto de procesos trabajadores. Esto facilita la asignación de tareas y la recolección de sus resultados. Comúnmente se utiliza la función map() y apply() de la clase Pool para lograr una ejecución paralela.

Usando map() y apply() en la Clase Pool

Función map():

El método map() aplica la función suministrada a cada elemento de un iterable y divide la carga entre los procesos disponibles. Devuelve una lista de resultados en el mismo orden en que se introdujeron los valores de entrada. Aquí hay una ilustración:

import multiprocessing

def square(number):
    return number ** 2

if __name__ == "__main__":
    input_data = [1, 2, 3, 4, 5]

    with multiprocessing.Pool() as pool:
        results = pool.map(square, input_data)

    print("Resultados al cuadrado:", results)

Función apply():

Cuando necesita aplicar una función a un solo parámetro en un conjunto de procesos, utiliza la función apply(). Devuelve el resultado de aplicar la función al valor de entrada. Aquí hay una ilustración:

import multiprocessing

def cube(number):
    return number ** 3

if __name__ == "__main__":
    number = 4

    with multiprocessing.Pool() as pool:
        result = pool.apply(cube, (number,))

    print(f"{number} al cubo es:", result)

Escenarios en los que el Pooling Mejora el Rendimiento

Tareas Ligadas a la CPU: La clase Pool puede ejecutar versiones paralelas de tareas que requieren mucha potencia de CPU, como simulaciones o cálculos. Los múltiples núcleos de CPU se pueden utilizar de manera efectiva distribuyendo la carga entre las tareas activas.

Procesamiento de Datos: La clase Pool puede manejar muchos componentes de un conjunto de datos simultáneamente al tratar tareas de procesamiento de datos como transformación de datos, filtrado o análisis. El tiempo de procesamiento puede acortarse significativamente como resultado.

Web Scraping: La clase Pool puede solicitar datos de varias URL al mismo tiempo mientras extrae información de múltiples sitios web. Esto acelera el proceso de recopilación de datos.

Sincronización y Bloqueo: Cuando dos o más procesos acceden simultáneamente a los mismos recursos compartidos o variables en un sistema de multiprocesamiento, ocurren condiciones de carrera, lo que resulta en un comportamiento impredecible o inexacto. Las condiciones de carrera pueden causar corrupción de datos, bloqueos y resultados incorrectos en el programa. Se evitan la integridad de los datos y las condiciones de carrera utilizando técnicas de sincronización como los bloqueos.

Usando Bloqueos para Evitar Condiciones de Carrera

El primitivo de sincronización conocido como “bloqueo” (abreviatura de “exclusión mutua”) asegura que solo un proceso pueda acceder a un código crucial o un recurso compartido en un momento dado. Una vez que un proceso tiene un bloqueo, tiene acceso exclusivo a la región protegida y no puede ser accedido por otros procesos hasta que se libere el bloqueo.

Al requerir que los procesos accedan a los recursos secuencialmente, los bloqueos crean una forma de cooperación que evita las situaciones de carrera.

Ejemplos de Bloqueos Utilizados para Proteger la Integridad de los Datos

import multiprocessing

def incrementar(contador, bloqueo):
    for _ in range(100000):
        with bloqueo:
            contador.value += 1

if __name__ == "__main__":
    contador = multiprocessing.Value("i", 0)
    bloqueo = multiprocessing.Lock()

    procesos = []

    for _ in range(4):
        proceso = multiprocessing.Process(target=incrementar, args=(contador, bloqueo))
        procesos.append(proceso)
        proceso.start()

    for proceso in procesos:
        proceso.join()

    print("Valor final del contador:", contador.value)

Diferenciando Tareas Ligadas a la CPU y Tareas Ligadas a E/S

Tareas Ligadas a la CPU: Una tarea ligada a la CPU utiliza ampliamente las capacidades de procesamiento de la CPU. Estos trabajos requieren muchos recursos de CPU, como cálculos complejos, operaciones matemáticas, simulaciones y procesamiento de datos. Las tareas ligadas a la CPU rara vez interactúan con recursos externos como archivos y redes, y pasan la mayor parte de su tiempo ejecutando código.

Tareas Ligadas a E/S: Las tareas ligadas a E/S incluyen lectura y escritura de archivos, envío de solicitudes a través de redes y comunicación con bases de datos, todo lo cual requiere un tiempo considerable de espera para que las operaciones de E/S se completen. Estas tareas pasan más tiempo “esperando” a que las operaciones de E/S se completen que utilizando activamente la CPU.

Gestión de tareas intensivas en CPU con grupos de procesos

Los grupos de procesos son beneficiosos para controlar cargas de trabajo intensivas en CPU. Los grupos de procesos dividen las tareas que consumen CPU en varios procesos para que puedan ejecutarse de forma concurrente en diferentes núcleos de CPU, ya que la mayoría de las veces implican cálculos que se pueden paralelizar. Esto acorta considerablemente el tiempo de ejecución y utiliza de manera eficaz los recursos de CPU disponibles.

Utilizando grupos de procesos, puedes asegurarte de que los procesadores multinúcleo se utilicen al máximo para finalizar tareas intensivas en CPU más rápidamente. La clase Pool del módulo multiprocessing facilita la creación y gestión de estos procesos de trabajo.

Programación asíncrona para tareas ligadas a E/S

La programación asíncrona es una estrategia adecuada para trabajos ligados a E/S, donde el cuello de botella principal es la espera de operaciones de E/S (como lectura/escritura de archivos o solicitudes de red). Al realizar una transición efectiva entre actividades mientras se espera la E/S, la programación asíncrona permite que un solo hilo gestione numerosas tareas de forma concurrente en lugar de utilizar múltiples procesos.

No es necesario configurar procesos separados, como grupos de procesos, al utilizar programación asíncrona. En cambio, emplea una estrategia de multitarea cooperativa, donde las actividades renuncian al control del bucle de eventos mientras esperan que ocurra la E/S para que otras tareas puedan continuar con su trabajo. Esto puede mejorar significativamente la capacidad de respuesta de las aplicaciones ligadas a E/S.

Factores que afectan el rendimiento de la multiprocesamiento

Varios factores influyen en el rendimiento de las soluciones de multiprocesamiento:

Naturaleza de la tarea: Las posibles ventajas de rendimiento del multiprocesamiento dependen de si una tarea está ligada a la CPU o a la E/S. Las operaciones ligadas a la E/S pueden ver solo modestos beneficios de rendimiento debido a la espera de recursos externos, pero las tareas ligadas a la CPU se benefician más, ya que pueden aprovechar varios núcleos.
Número de núcleos: La aceleración potencial lograda mediante el multiprocesamiento depende directamente del número de núcleos de CPU disponibles. Cuantos más núcleos haya, mayor será la ejecución paralela. Los procesos deben coordinarse y comunicarse entre sí, lo que añade sobrecarga. Las colas y otras técnicas de comunicación eficaces ayudan a reducir esta sobrecarga.
Granularidad de la tarea: Dividir las tareas en fragmentos más pequeños puede aumentar el paralelismo y el equilibrio de carga. Sin embargo, puede introducir sobrecarga de comunicación en actividades muy detalladas.

Comparación de implementaciones mediante benchmarks

A continuación se muestra una comparación ilustrativa de diferentes implementaciones utilizando una tarea simple ligada a la CPU para calcular factoriales:

import time
import multiprocessing
import threading
import math

def factorial(n):
    return math.factorial(n)

def single_thread():
    for _ in range(4):
        factorial(5000)

def multi_thread():
    threads = []
    for _ in range(4):
        thread = threading.Thread(target=factorial, args=(5000,))
        threads.append(thread)
        thread.start()
    for thread in threads:
        thread.join()

def multi_process():
    processes = []
    for _ in range(4):
        process = multiprocessing.Process(target=factorial, args=(5000,))
        processes.append(process)
        process.start()
    for process in processes:
        process.join()

if __name__ == "__main__":
    start_time = time.time()
    single_thread()
    print("Un solo hilo:", time.time() - start_time)

    start_time = time.time()
    multi_thread()
    print("Multi-hilo:", time.time() - start_time)

    start_time = time.time()
    multi_process()
    print("Multi-procesamiento:", time.time() - start_time)

Abordar la sobrecarga y los compromisos

El multiprocesamiento tiene desventajas incluso si puede mejorar significativamente el rendimiento de las tareas ligadas a la CPU:

Sobrecarga de comunicación: Al desarrollar y ejecutar procesos, puede haber una sobrecarga significativa de comunicación, especialmente para operaciones simples. Es importante encontrar un equilibrio entre la sobrecarga y el tiempo de procesamiento.
Uso de memoria: Debido a que cada proceso tiene su propia área de memoria, el uso de memoria puede aumentar. Es crucial manejar la memoria con cuidado.
Escalabilidad: Si bien el multiprocesamiento mejora el rendimiento en sistemas multinúcleo, un paralelismo demasiado intenso puede no resultar en una aceleración proporcional debido a la sobrecarga de comunicación.
Distribución de tareas: Para una ejecución equilibrada, es esencial dividir las tareas de manera efectiva y gestionar la carga de trabajo entre los procesos.

Visualización con Matplotlib

Una técnica efectiva para comprender el comportamiento y los efectos del multiprocesamiento es la visualización. Puedes seguir el progreso de los procesos, evaluar datos para diferentes escenarios y mostrar visualmente las mejoras de rendimiento del procesamiento paralelo mediante gráficos y diagramas.

Ejemplos de Uso de Matplotlib para Visualización

A continuación se presentan dos ejemplos de cómo se puede utilizar Matplotlib para visualizar la ejecución y la aceleración de la multiprocesamiento:

Ejemplo 1: Visualización de la Ejecución de Procesos

Consideremos un escenario en el que estás procesando un lote de imágenes utilizando varios procesos. Puedes visualizar el progreso de cada proceso utilizando un gráfico de barras:

import multiprocessing
import time
import matplotlib.pyplot as plt

def process_image(image):
    time.sleep(2)  # Simulando el procesamiento de imágenes
    return f"Procesada {image}"

if __name__ == "__main__":
    images = ["imagen1.jpg", "imagen2.jpg", "imagen3.jpg", "imagen4.jpg"]
    num_processes = 4

    with multiprocessing.Pool(processes=num_processes) as pool:
        results = pool.map(process_image, images)

    plt.bar(range(len(images)), [1] * len(images), align="center", color="blue", 
    label="Procesando")
    plt.bar(range(len(results)), [1] * len(results), align="center", color="green", 
    label="Procesada")

    plt.xticks(range(len(results)), images)
    plt.ylabel("Progreso")
    plt.title("Progreso del Procesamiento de Imágenes")
    plt.legend()

    plt.show()

Ejemplo 2: Comparación de Aceleración

import time
import threading
import multiprocessing
import matplotlib.pyplot as plt

def task():
    time.sleep(1)  # Simulando trabajo

def ejecucion_con_un_solo_hilo():
    for _ in range(4):
        task()

def ejecucion_con_multiples_hilos():
    threads = []
    for _ in range(4):
        thread = threading.Thread(target=task)
        threads.append(thread)
        thread.start()
    for thread in threads:
        thread.join()

def ejecucion_con_multiples_procesos():
    processes = []
    for _ in range(4):
        process = multiprocessing.Process(target=task)
        processes.append(process)
        process.start()
    for process in processes:
        process.join()

if __name__ == "__main__":
    tiempos = []

    tiempo_inicio = time.time()
    ejecucion_con_un_solo_hilo()
    tiempos.append(time.time() - tiempo_inicio)

    tiempo_inicio = time.time()
    ejecucion_con_multiples_hilos()
    tiempos.append(time.time() - tiempo_inicio)

    tiempo_inicio = time.time()
    ejecucion_con_multiples_procesos()
    tiempos.append(time.time() - tiempo_inicio)

    etiquetas = ["Un solo Hilo", "Múltiples Hilos", "Múltiples Procesos"]
    plt.bar(etiquetas, tiempos)
    plt.ylabel("Tiempo de Ejecución (s)")
    plt.title("Comparación de Aceleración")

    plt.show()

Aplicación

En muchos sectores donde las tareas se pueden descomponer en unidades de trabajo más pequeñas que se pueden completar de forma concurrente, la multiprocesamiento es vital. A continuación, se presentan algunos escenarios del mundo real donde la multiprocesamiento es crucial:

Procesamiento de datos: Los procesos mantienen la segregación, evitando el intercambio directo de memoria. La comunicación entre procesos (IPC) es uno de los mecanismos más complejos para facilitar la comunicación de proceso a proceso. Con su tamaño sustancial y su aislamiento inherente, los procesos demuestran una eficiencia excepcional en la gestión de tareas intensivas en recursos, como la ejecución de múltiples programas independientes.
Procesamiento de imágenes y videos: La multiprocesamiento puede ayudar a aplicar filtros, escalado y detección de objetos en imágenes y videos. Maneja cada imagen o fotograma en paralelo para acelerar las operaciones y permitir el procesamiento en tiempo real en aplicaciones de video.

La multiprocesamiento puede acelerar los procesos de web scraping y crawling, recopilando datos de numerosos sitios web. La recopilación y análisis de datos utilizando múltiples procedimientos para extraer datos de diversas fuentes.

Aprendizaje profundo y aprendizaje automático: El uso de conjuntos de datos masivos para entrenar modelos de aprendizaje automático a menudo requiere actividades computacionalmente exigentes. El uso de varios núcleos o GPUs para operaciones de datos y entrenamiento reduce el tiempo de entrenamiento y mejora la convergencia del modelo.

Computación paralela y análisis numérico: La multiprocesamiento es útil para cálculos matemáticos a gran escala, soluciones de problemas complejos y simulaciones numéricas. Las computaciones paralelas de matrices y las simulaciones de Monte Carlo son dos ejemplos de técnicas.

El procesamiento por lotes es necesario para muchas aplicaciones, como la renderización de fotogramas de animación o la generación de informes en programas empresariales. La ejecución paralela eficiente de estas actividades se logra mediante la multiprocesamiento.

Modelado Financiero

Las simulaciones financieras complejas, el análisis de riesgos y el modelado de escenarios pueden implicar muchos cálculos. La multiprocesamiento acelera estos cálculos, permitiendo una toma de decisiones y análisis más rápidos.

Conclusión

Explorar las capacidades de multiprocesamiento de Python te brinda el poder de mejorar el rendimiento de tu código y acelerar las aplicaciones. Este viaje ha revelado la compleja interacción de hilos, procesos y el poder del módulo de multiprocesamiento. El multiprocesamiento da nueva vida, ofreciendo eficiencia y optimización. Recuerda que el multiprocesamiento es tu clave para la innovación, velocidad y eficiencia mientras nos despedimos. Tus habilidades recién adquiridas te preparan para proyectos difíciles, incluyendo simulaciones complejas y actividades intensivas en datos. Deja que esta información alimente tu entusiasmo por la programación, impulsando la efectividad y el impacto de tus aplicaciones. El viaje continúa, y ahora que tienes el multiprocesamiento a tu disposición, las posibilidades de tu código son ilimitadas.

Puntos clave

El multiprocesamiento implica ejecutar múltiples procesos de manera simultánea, lo que permite que los programas aprovechen los procesadores multinúcleo modernos para un rendimiento óptimo.
Procesos: Unidades de ejecución aisladas con su propio espacio de memoria, mientras que los hilos comparten memoria dentro de un proceso. Comprender las diferencias ayuda a elegir el enfoque de concurrencia adecuado.
La GIL (Global Interpreter Lock) de Python limita la ejecución paralela real en escenarios multihilo, lo que hace que el multiprocesamiento sea más adecuado para tareas con uso intensivo de CPU que requieren cálculos intensivos.
Los mecanismos de comunicación entre procesos (IPC, por sus siglas en inglés), como tuberías, colas y memoria compartida, permiten que los procesos se comuniquen e intercambien datos de manera segura.
La naturaleza de la tarea, el número de núcleos, el impacto de la GIL, la sobrecarga de comunicación, el uso de memoria y la granularidad de la tarea afectan el rendimiento del multiprocesamiento. Se debe tener en cuenta cuidadosamente para equilibrar el uso de recursos y lograr una escalabilidad óptima.

Preguntas frecuentes

Los medios mostrados en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!

blogathoncommunicationCPUjobsmemoryPythonresourcesthreadingtime

Was this article helpful?

93 out of 132 found this helpful