Python / IPC con queues

Bienvenidos sean a este post, hoy hablaremos como hacer IPC con queues.

En el post anterior vimos como se intercomunicaban entre dos threads por medio de Queue, ahora nos toca con los procesos y para ello vamos a trabajar con un ejemplo, para ello primero importemos lo que necesitamos:

>>> import multiprocessing

Con nuestro modulo importado podemos pasar a establecer la siguiente variable:

>>> CENTINELA = 'PARAR'

Este trabaja de forma similar a lo visto en el post anterior pero en lugar de ser un objeto sera una variable con un valor, pasemos a definir la primera funcion:

>>> def productor(e, n):
...     a, b = 0, 1
...     while a <= n:
...             e.put(a)
...             a, b = b, a + b
...     e.put(CENTINELA)
... 
>>>

Si lo analizamos es muy similar a lo visto en el post anterior, donde tenemos dos variables, luego un bucle que se hara mientras a sea menor a n, luego agregaremos los valores dentro del queue que fue informado en el atributo de la funcion, despues haremos la secuencia fibonacci, donde el valor de a sera reemplazado por b, luego hace la suma de ambos y la almacena en b, una vez terminado el ciclo procede a pasar CENTINELA al Queue, pasemos a definir la siguiente funcion:

>>> def consumidor(e):
...     while True:
...             num = e.get()
...             if num == CENTINELA:
...                     break
...             print(f'Numero obtenido {num}')
... 
>>>

Este tambien es muy similar a lo visto en el post anterior, tenemos un bucle infinito mientras sea True se hara, luego en num obtenemos los distintos valores del Queue informado como atributo, despues de esto tenemos un condicional donde verifica si num es igual CENTINELA, en caso de ser verdadero ejecuta un break y sale del bucle de lo contrario ira mostrando el valor almacenado en num, a diferencia de la comunicacion entre threads no utilizamos el task_done sino que simplemente chequeamos por pasada, con esto comentado pasemos a crear el objeto para Queue:

>>> e = multiprocessing.Queue()

Esto es muy similar a como trabajamos con threads, lo siguiente sera crear los dos procesos que utilizaremos para que se comuniquen:

>>> prd = multiprocessing.Process(target=productor, args=(e, 35))
>>> cns = multiprocessing.Process(target=consumidor, args=(e, ))

En este caso crearemos los dos procesos que contendran una funcion cada una, en el caso del productor pasamos el objeto de Queue y un valor para limitarlo, en el caso del consumidor solo pasamos el objeto de Queue, al igual que con los threads iniciaremos al proceso asignado al consumidor:

>>> cns.start()

Este iniciara el proceso y volvera nuevamente al interprete esperando a que el productor entre en accion, pasemos a ejecutar el productor:

>>> prd.start()

Cuando ejecutemos esto procedera a mostrarnos todos los valores de la serie Fibonacci:

>>> Numero obtenido 0
Numero obtenido 1
Numero obtenido 1
Numero obtenido 2
Numero obtenido 3
Numero obtenido 5
Numero obtenido 8
Numero obtenido 13
Numero obtenido 21
Numero obtenido 34

Diferencia con los threads, la mas notoria es que no debemos hacer esperar (wait) a la funcion hasta que el emisor este activo por lo contrario esperara automaticamente hasta que se active, tampoco necesitamos una funcion que verifique si se completo la tarea pero si recuerdan su problema mas importante es que consume mas memoria y tiempo de CPU que un thread pero como se habran dado cuenta en terminos generales es muy similar a cuando trabajamos con los threads.

En resumen, hoy hemos visto como usar la comunicacion entre procesos (IPC) por medio de Queue, hemos visto que es muy similar al realizado con threads, pero tiene un par de sutiles diferencias, con respecto a la espera de cuando uno esta activo o no, tambien hemos visto como nos ahorramos algunos pasos con respecto a la otra forma pero sin olvidar los inconvenientes que puede traernos, espero les haya sido util sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.