Crea múltiples procesos en python

Actualmente, la mayoría de los fabricantes de procesadores fabrican procesadores multinúcleo. ¡El teléfono también es multinúcleo! Los subprocesos de Python no pueden usar estos núcleos debido al bloqueo global del intérprete. Python 2.6 o posterior, Se agregó un módulo que le permite aprovechar todos los núcleos de su máquina «multiprocessing«.

Recomendado: frameworks de python

Este artículo no es una descripción completa del multiprocesamiento. Los temas generales de multiprocesamiento y concurrencia caben en sus propios libros. Puede ver la documentación en cualquier momento para multiprocessing,

Si necesitas los módulos están aquí:

¡Entonces empecemos!

Ventajas de usar este proceso

Hay varias ventajas al usar este proceso.

  • El proceso utiliza un espacio de memoria separado.
  • El código puede ser más simple en comparación con los hilos
  • Usar múltiples procesadores/núcleos
  • Evite el bloqueo de intérprete global (GIL)
  • Puedes matar un subproceso (a diferencia de un hilo)
  • Este El módulo(multiprocessing) tiene las siguientes interfaces threading.Thread
  • Bueno para el procesamiento intensivo de la CPU (cifrado, búsqueda binaria, multiplicación de matrices)

Ahora veamos algunas de las desventajas de este proceso.

Desventajas de usar el proceso.

También hay algunas desventajas al usar este proceso.

  • La comunicación entre procesos es más compleja.
  • El uso de la memoria es mayor que el subproceso

¡Ahora aprendamos cómo crear un proceso en Python!

Recomendado: ¿ Quién invento Python ?

Crear un proceso multiprocessing

Este modulo multiprocessing  es threading.Thread.

Aquí hay un ejemplo de uso del modulo multiprocessing:

import multiprocessing
import random
import time


def worker(name: str) -> None:
    print(f'Started worker ')
    worker_time = random.choice(range(1, 5))
    time.sleep(worker_time)
    print(f' worker finished in  seconds')

if __name__ == '__main__':
    processes = []
    for i in range(5):
        process = multiprocessing.Process(target=worker, 
                                          args=(f'computer_',))
        processes.append(process)
        process.start()
        
    for proc in processes:
        proc.join()

El primer paso es importar multiprocessing. Las otras dos importaciones son random y time.

La función worker()  que pretende hacer un trabajo, name no devuelve nada. Se ejecuta función worker(), imprime name trabajador, entonces usa time.sleep() Simula la ejecución de un proceso de larga duración.

Finalmente, la impresión está completa.

Recomendado: Árbol de decisión SkLearn

La última parte del fragmento de código es donde crea los cinco procesos de trabajo. multiprocessing.Process()Es casi lo mismo threading.Thread() Terminado dices Process La función objetivo a usar y los argumentos a pasarle. La principal diferencia es que esta vez creamos una lista con list , para cada proceso start().

Finalmente, revise la lista de procesos con el método join(). Python esperara a que se complete el proceso.

Cuando ejecuto este código, obtengo un resultado similar a este:

Started worker computer_2
computer_2 worker finished in 2 seconds
Started worker computer_1
computer_1 worker finished in 3 seconds
Started worker computer_3
computer_3 worker finished in 3 seconds
Started worker computer_0
computer_0 worker finished in 4 seconds
Started worker computer_4
computer_4 worker finished in 4 seconds

Cada vez que ejecute el script, el resultado será ligeramente diferente que el módulo random.

Subclase Process

Con esta clases Process de multiprocessing Los módulos también se pueden subclasificar. Funciona casi igual. threading.Thread.

Vamos a ver:

# worker_thread_subclass.py

import random
import multiprocessing
import time

class WorkerProcess(multiprocessing.Process):

    def __init__(self, name):
        multiprocessing.Process.__init__(self)
        self.name = name

    def run(self):
        """
        Run the thread
        """
        worker(self.name)

def worker(name: str) -> None:
    print(f'Started worker ')
    worker_time = random.choice(range(1, 5))
    time.sleep(worker_time)
    print(f' worker finished in  seconds')

if __name__ == '__main__':
    processes = []
    for i in range(5):
        process = WorkerProcess(name=f'computer_')
        processes.append(process)
        process.start()

    for process in processes:
        process.join()

Subclase multiprocess.Process() sobre método run() .

Luego, al final del código, dentro del ciclo, cree un proceso y agréguelo a la lista de procesos. Luego, para que el proceso funcione, revise la lista de procesos y llámelo con join() a cada uno de ellos. Esto es exactamente lo mismo que el ejemplo de proceso anterior en la sección anterior.

La salida de esta clase debe ser muy similar a la salida de la sección anterior.

Crear un grupo de procesos

Si tiene muchos procesos para ejecutar, es posible que desee limitar la cantidad de procesos que pueden ejecutarse al mismo tiempo. Por ejemplo, suponga que tiene una CPU que necesita ejecutar 20 procesos pero solo tiene 4 núcleos, puede usar esto multiprocessing Un módulo que crea un grupo de procesos que limita la cantidad de procesos que se ejecutan al mismo tiempo a cuatro.

Así es cómo funciona:

import random
import time

from multiprocessing import Pool


def worker(name: str) -> None:
    print(f'Started worker ')
    worker_time = random.choice(range(1, 5))
    time.sleep(worker_time)
    print(f' worker finished in  seconds')

if __name__ == '__main__':
    process_names = [f'computer_' for i in range(15)]
    pool = Pool(processes=5)
    pool.map(worker, process_names)
    pool.terminate()

En este ejemplo, tienen el mismo worker(). La esencia del código es al final usar una lista de comprensión para crear 15 nombres de procesos. Para que con Pool Establezca el número total de procesos para ejecutar simultáneamente en 5. Con pooltienes que llamar map() que cree un método y pase la función para llamar y los parámetros para pasar a la función.

Python ejecuta cinco procesos (o menos) a la vez hasta que finalicen todos. Debe llamar terminate() Al final está en el pool, de lo contrario verás un mensaje similar al siguiente:

/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/multiprocessing/resource_tracker.py:216: 
UserWarning: resource_tracker: There appear to be 6 leaked semaphore objects to clean up at shutdown

Ahora sabe cómo crear un proceso Pool

Palabras finales

Ahora conoce los conceptos básicos de uso del módulo multiprocessing. Has aprendido lo siguiente:

  • Ventajas de usar este proceso
  • Desventajas de usar el proceso.
  • Crear un proceso multiprocessing
  • Subclase Process
  • Crear un grupo de procesos

Hay muchos más multiprocessing Más de lo que se cubre aquí. Puedes aprender a usar Python Queue Un módulo para obtener la salida de un proceso. Hay un tema de comunicación entre procesos. hay más. Sin embargo, el objetivo es aprender a crear procesos, multiprocessing. La simultaneidad es un tema importante que requiere más detalles de los que cubre este artículo.

¿ Te fue útil este artículo ?
⬇️ Ayudame compartiendo para poder llegar a más personas.⬇️