multiple - python parallel execution

Python multiprocessing.Queue vs multiprocessing.manager(). Queue()

Question

Tengo una tarea simple como esa:

def worker(queue):
while True:
try:
_ = queue.get_nowait()
except Queue.Empty:
break
if __name__ == ''__main__'':
manager = multiprocessing.Manager()
# queue = multiprocessing.Queue()
queue = manager.Queue()
for i in range(5):
queue.put(i)
processes = []
for i in range(2):
proc = multiprocessing.Process(target=worker, args=(queue,))
processes.append(proc)
proc.start()
for proc in processes:
proc.join()

Parece que el multiprocesamiento.Queue puede hacer todo el trabajo que necesitaba, pero por otro lado veo muchos ejemplos de manager (). Queue () y no puedo entender lo que realmente necesito. Parece que Manager (). Queue () usa algún tipo de objetos proxy, pero no entiendo ese propósito, porque multiprocessing.Queue () hace el mismo trabajo sin ningún objeto proxy.

Entonces, mi pregunta es:

1) ¿Qué diferencia realmente hay entre multiprocessing.Queue y el objeto devuelto por multiprocessing.manager (). Queue ()?

2) ¿Qué necesito usar?

Answer 1

Aunque mi entendimiento es limitado sobre este tema, por lo que hice, puedo decir que hay una diferencia principal entre multiprocessing.Queue () y multiprocessing.Manager (). Queue ():

• multiprocessing.Queue () es un objeto mientras multiprocessing.Manager (). Queue () es una dirección (proxy) que apunta a una cola compartida administrada por el objeto multiprocessing.Manager ().
• por lo tanto, no puede pasar objetos de multiprocesamiento.Queue () normales a los métodos de agrupación, ya que no puede ser decapado.
• Además, el documento de Python nos dice que prestemos especial atención al usar multiprocessing.Queue () porque puede tener efectos no deseados.

Nota Cuando un objeto se pone en una cola, el objeto se conserva en vinagre y, posteriormente, un subproceso en segundo plano vacía los datos en vinagre a un conducto subyacente. Esto tiene algunas consecuencias que son un poco sorprendentes, pero no deberían causar ninguna dificultad práctica. Si realmente te molestan, puedes utilizar una cola creada con un administrador. Después de colocar un objeto en una cola vacía, puede haber un retraso infinitesimal antes de que el método empty () de la cola devuelva False y get_nowait () pueda regresar sin elevar Queue.Empty. Si hay varios procesos en cola para colocar objetos, es posible que los objetos se reciban en el otro extremo fuera de orden. Sin embargo, los objetos puestos en cola por el mismo proceso siempre estarán en el orden esperado entre sí.

Advertencia Como se mencionó anteriormente, si un proceso secundario ha puesto elementos en una cola (y no ha usado JoinableQueue.cancel_join_thread), ese proceso no terminará hasta que todos los elementos almacenados en el búfer hayan sido vaciados en la tubería. Esto significa que si intenta unirse a ese proceso, puede obtener un interbloqueo a menos que esté seguro de que todos los elementos que se han puesto en la cola se han consumido. De manera similar, si el proceso hijo no es demoníaco, el proceso padre puede colgarse en la salida cuando intenta unirse a todos sus hijos no demoníacos. Tenga en cuenta que una cola creada con un administrador no tiene este problema.

Existe una solución alternativa para usar multiprocessing.Queue () con Pool configurando la cola como una variable global y configurándola para todos los procesos en la inicialización:

queue = multiprocessing.Queue()
def initialize_shared(q):
global queue
queue=q
pool= Pool(nb_process,initializer=initialize_shared, initargs(queue,))

creará procesos de grupo con colas compartidas correctamente pero podemos argumentar que los objetos multiprocessing.Queue () no se crearon para este uso.

Por otro lado, manager.Queue () se puede compartir entre subprocesos de grupo pasándolo como argumento normal de una función.

En mi opinión, usar multiprocessing.Manager (). Queue () está bien en todos los casos y menos problemático. Puede haber algunos inconvenientes en el uso de un administrador, pero no lo conozco.