Python multiproceso espere hasta que todos los hilos terminen

Es posible que esto se haya preguntado en un contexto similar, pero no pude encontrar una respuesta después de unos 20 minutos de búsqueda, así que preguntaré.

He escrito un script de Python (digamos: scriptA.py) y un script (digamos scriptB.py)

En scriptB quiero llamar a scriptA varias veces con diferentes argumentos, cada vez tarda aproximadamente una hora en ejecutarse (es un script enorme, hace muchas cosas ... no se preocupe) y quiero poder ejecutar el scriptA con todos los diferentes argumentos simultáneamente, pero necesito esperar hasta que TODOS estén listos antes de continuar; mi código:

import subprocess

#setup
do_setup()

#run scriptA
subprocess.call(scriptA + argumentsA)
subprocess.call(scriptA + argumentsB)
subprocess.call(scriptA + argumentsC)

#finish
do_finish()

Quiero ejecutar todos subprocess.call()al mismo tiempo, y luego esperar hasta que terminen, ¿cómo debo hacer esto?

Traté de usar subprocesos como el ejemplo aquí :

from threading import Thread
import subprocess

def call_script(args)
    subprocess.call(args)

#run scriptA   
t1 = Thread(target=call_script, args=(scriptA + argumentsA))
t2 = Thread(target=call_script, args=(scriptA + argumentsB))
t3 = Thread(target=call_script, args=(scriptA + argumentsC))
t1.start()
t2.start()
t3.start()

Pero no creo que esto sea correcto.

¿Cómo sé que han terminado de correr antes de ir a mi do_finish()?

Debe utilizar el método de unión del Threadobjeto al final del script.

t1 = Thread(target=call_script, args=(scriptA + argumentsA))
t2 = Thread(target=call_script, args=(scriptA + argumentsB))
t3 = Thread(target=call_script, args=(scriptA + argumentsC))

t1.start()
t2.start()
t3.start()

t1.join()
t2.join()
t3.join()

Así, el hilo principal esperará hasta t1, t2y t3terminar la ejecución.

Coloque los hilos en una lista y luego use el método Join

 threads = []

 t = Thread(...)
 threads.append(t)

 ...repeat as often as necessary...

 # Start all threads
 for x in threads:
     x.start()

 # Wait for all of them to finish
 for x in threads:
     x.join()

En Python3, desde Python 3.2 hay un nuevo enfoque para alcanzar el mismo resultado, que personalmente prefiero al paquete tradicional de creación / inicio / unión de subprocesos concurrent.futures: https://docs.python.org/3/library/concurrent.futures .html

Usar un ThreadPoolExecutorcódigo sería:

from concurrent.futures.thread import ThreadPoolExecutor
import time

def call_script(ordinal, arg):
    print('Thread', ordinal, 'argument:', arg)
    time.sleep(2)
    print('Thread', ordinal, 'Finished')

args = ['argumentsA', 'argumentsB', 'argumentsC']

with ThreadPoolExecutor(max_workers=2) as executor:
    ordinal = 1
    for arg in args:
        executor.submit(call_script, ordinal, arg)
        ordinal += 1
print('All tasks has been finished')

La salida del código anterior es algo como:

Thread 1 argument: argumentsA
Thread 2 argument: argumentsB
Thread 1 Finished
Thread 2 Finished
Thread 3 argument: argumentsC
Thread 3 Finished
All tasks has been finished

Una de las ventajas es que puede controlar el rendimiento estableciendo el máximo de trabajadores simultáneos.

Prefiero usar la comprensión de la lista basada en una lista de entrada:

inputs = [scriptA + argumentsA, scriptA + argumentsB, ...]
threads = [Thread(target=call_script, args=(i)) for i in inputs]
[t.start() for t in threads]
[t.join() for t in threads]

Puede tener una clase como la siguiente desde la que puede agregar 'n' número de funciones o scripts de consola que desea ejecutar en paralelo y comenzar la ejecución y esperar a que se completen todos los trabajos.

from multiprocessing import Process

class ProcessParallel(object):
    """
    To Process the  functions parallely

    """    
    def __init__(self, *jobs):
        """
        """
        self.jobs = jobs
        self.processes = []

    def fork_processes(self):
        """
        Creates the process objects for given function deligates
        """
        for job in self.jobs:
            proc  = Process(target=job)
            self.processes.append(proc)

    def start_all(self):
        """
        Starts the functions process all together.
        """
        for proc in self.processes:
            proc.start()

    def join_all(self):
        """
        Waits untill all the functions executed.
        """
        for proc in self.processes:
            proc.join()


def two_sum(a=2, b=2):
    return a + b

def multiply(a=2, b=2):
    return a * b


#How to run:
if __name__ == '__main__':
    #note: two_sum, multiply can be replace with any python console scripts which
    #you wanted to run parallel..
    procs =  ProcessParallel(two_sum, multiply)
    #Add all the process in list
    procs.fork_processes()
    #starts  process execution 
    procs.start_all()
    #wait until all the process got executed
    procs.join_all()

De la threading documentación del módulo

Hay un objeto "hilo principal"; esto corresponde al hilo de control inicial en el programa Python. No es un hilo de demonio.

Existe la posibilidad de que se creen "objetos de hilo ficticio". Estos son objetos de subprocesos correspondientes a "subprocesos ajenos", que son subprocesos de control iniciados fuera del módulo de subprocesos, como directamente desde el código C. Los objetos de hilo ficticio tienen una funcionalidad limitada; siempre se consideran vivos y demoníacos, y no se pueden join()editar. Nunca se eliminan, ya que es imposible detectar la terminación de hilos extraños.

Entonces, para detectar esos dos casos en los que no está interesado en mantener una lista de los hilos que crea:

import threading as thrd


def alter_data(data, index):
    data[index] *= 2


data = [0, 2, 6, 20]

for i, value in enumerate(data):
    thrd.Thread(target=alter_data, args=[data, i]).start()

for thread in thrd.enumerate():
    if thread.daemon:
        continue
    try:
        thread.join()
    except RuntimeError as err:
        if 'cannot join current thread' in err.args[0]:
            # catchs main thread
            continue
        else:
            raise

Después de lo cual:

>>> print(data)
[0, 4, 12, 40]

Tal vez algo como

for t in threading.enumerate():
    if t.daemon:
        t.join()

Me encontré con el mismo problema en el que necesitaba esperar todos los subprocesos que se crearon usando el bucle for. Acabo de probar el siguiente código. Puede que no sea la solución perfecta, pero pensé que sería una solución simple. Probar:

for t in threading.enumerate():
    try:
        t.join()
    except RuntimeError as err:
        if 'cannot join current thread' in err:
            continue
        else:
            raise