Introducción a Multiprocesamiento en Python

() translation by (you can also view the original English article)

El paquete de multiprocesamiento apoya los procesos de desove utilizando una API similar al módulo threading. También ofrece concurrencia local y remota. Este tutorial explicará multiprocesamiento en Python y cómo utilizar multiproceso para comunicarse entre procesos y realizar la sincronización entre procesos, así como registro.

Introducción a Multiprocesador

Multiprocesamiento funciona creando un objeto del process y luego llamando a su método start() como se muestra a continuación.

from multiprocessing import Process


def greeting():
    print 'hello world'

if __name__ == '__main__':
    p = Process(target=greeting)
    p.start()
    p.join()

En el código de ejemplo anterior, primero importamos la clase de proceso y luego instanciar el objeto del proceso con la función de saludo que queremos ejecutar.

Luego contamos el proceso para comenzar a usar el método start(), y finalmente terminamos el proceso con el método join().

Además, también puede pasar argumentos a la función proporcionando los argumentos argumento de palabra clave así:

from multiprocessing import Process


def greeting(name):
    print 'hello' + " " + name

if __name__ == '__main__':
    p = Process(target=greeting, args=('world',))
    p.start()
    p.join()

Ejemplo

Veamos un ejemplo más detallado que cubre todos los conceptos que hemos discutido anteriormente.

En este ejemplo, vamos a crear un proceso que calcula el cuadrado de números e imprime los resultados en la consola.

from multiprocessing import Process


def square(x):

    for x in numbers:
        print('%s squared  is  %s' % (x, x**2))

if __name__ == '__main__':
    numbers = [43, 50, 5, 98, 34, 35]

    p = Process(target=square, args=('x',))
    p.start()
    p.join
    print "Done"
    
    
#result
Done
43 squared  is  1849
50 squared  is  2500
5 squared  is  25
98 squared  is  9604
34 squared  is  1156
35 squared  is  1225


También puede crear más de un proceso al mismo tiempo, como se muestra en el ejemplo siguiente, en que el proceso p1 obtiene los resultados de los números cuadrados, mientras que el segundo proceso p2 comprueba si los números dados son incluso.

from multiprocessing import Process


def square(x):

    for x in numbers:
        print('%s squared  is  %s' % (x, x**2))


def is_even(x):

    for x in numbers:
        if x % 2 == 0:
            print('%s is an even number ' % (x))


if __name__ == '__main__':
    numbers = [43, 50, 5, 98, 34, 35]

    p1 = Process(target=square, args=('x',))
    p2 = Process(target=is_even, args=('x',))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print "Done"
    
#result

43 squared  is  1849
50 squared  is  2500
5 squared  is  25
98 squared  is  9604
34 squared  is  1156
35 squared  is  1225
50 is an even number 
98 is an even number 
34 is an even number 
Done


Comunicación Entre Procesos

Multiprocesamiento admite dos tipos de canales de comunicación entre procesos:

Tubos
Colas de trabajos

Colas de Trabajos

Objetos de cola se utilizan para pasar datos entre procesos. Puede almacenar cualquier objeto de Python capaz de salmuera, y se pueden utilizar como se muestra en el ejemplo siguiente:

import multiprocessing


def is_even(numbers, q):
    for n in numbers:
        if n % 2 == 0:
            q.put(n)

if __name__ == "__main__":

    q = multiprocessing.Queue()
    p = multiprocessing.Process(target=is_even, args=(range(20), q))

    p.start()
    p.join()

    while q:
        print(q.get())

En el ejemplo anterior, primero creamos una función que comprueba si un número está incluso y luego pone el resultado en el final de la cola. Luego crear una instancia de un objeto de cola y un objeto del proceso y comenzar el proceso.

Finalmente, comprueba si la cola está vacía, y si no, obtenemos los valores de la parte delantera de la cola e imprimir en la consola.

Hemos demostrado cómo compartir datos entre dos procesos mediante una cola, y el resultado es como se muestra a continuación.

1	# result
2
3	0
4	2
5	4
6	6
7	8
8	10
9	12
10	14
11	16
12	18

También es importante tener en cuenta que Python dispone de un módulo de cola que vive en el módulo de proceso y se utiliza para compartir datos entre subprocesos, a diferencia de la cola de multiprocesamiento que vive en la memoria compartida y se utiliza para compartir datos entre procesos.

Tubos

Tubos de multiprocesamiento se utilizan principalmente para comunicación entre procesos. Es tan simple como:

from multiprocessing import Process, Pipe

def f(conn):
    conn.send(['hello world'])
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print parent_conn.recv()   
    p.join()

Pipe() devuelve dos objetos de conexión que representan los dos extremos de la tubería. Cada objeto de conexión tiene métodos send() y recv(). Aquí creamos un proceso que imprime el Hola mundo de cadena y entonces comparte los datos.

Resultado

1	# result
2
3	['hello world']

Locks

Lock asegurándose de sólo un proceso se ejecuta en un momento, por lo tanto, bloquea otros procesos de ejecución de código similar. Esto permite que el proceso a realizar, y sólo entonces se puede lanzar la cerradura.

El siguiente ejemplo muestra un uso muy sencillo el método de bloqueo.

from multiprocessing import Process, Lock


def greeting(l, i):
    l.acquire()
    print 'hello', i
    l.release()

if __name__ == '__main__':
    lock = Lock()
    names = ['Alex', 'sam', 'Bernard', 'Patrick', 'Jude', 'Williams']

    for name in names:
        Process(target=greeting, args=(lock, name)).start()


#result
hello Alex
hello sam
hello Bernard
hello Patrick
hello Jude
hello Williams


En este código, importar primero el método de bloqueo, adquirirla, ejecutar la función de imprimir y luego suéltelo

Registro

El módulo de multiprocesamiento también proporciona soporte para el registro, aunque el paquete de registro no utiliza bloqueos para mensajes entre procesos pueden ser mezclado para arriba durante la ejecución.

Uso de registro es tan simple como:

1	import multiprocessing, logging
2	logger = multiprocessing.log_to_stderr()
3	logger.setLevel(logging.INFO)
4	logger.warning('Error has occurred')

Aquí en primer lugar importamos la tala y los módulos de multiprocesamiento, y luego definir el método de multiprocessing.log_to_stderr(), que realiza una llamada a get_logger() así como la adición de un controlador que envía salida a sys.stderr. Por último, establecemos el nivel de registrador y el mensaje que queremos transmitir.

Conclusión

Este tutorial ha cubierto lo que es necesario empezar con multiprocesamiento en Python. Multiprocesamiento supera el problema de GIL (bloqueo Global del intérprete) ya que aprovecha el uso de subprocesos en lugar de hilos.

Hay mucho más en la documentación de Python que no está cubierta en este tutorial, así que siéntete libre de visitar la documentación de Python multiprocesamiento y utilizar toda la potencia de este módulo.