il multithreading di python attende che tutti i thread siano terminati

Potrebbe essere stato chiesto in un contesto simile ma non sono riuscito a trovare una risposta dopo circa 20 minuti di ricerca, quindi chiederò.

Ho scritto uno script Python (diciamo: scriptA.py) e uno script (diciamo scriptB.py)

In scriptB voglio chiamare scriptA più volte con argomenti diversi, ogni volta impiega circa un'ora per essere eseguito, (è uno script enorme, fa molte cose .. non preoccuparti) e voglio essere in grado di eseguire il scriptA con tutti i diversi argomenti contemporaneamente, ma devo aspettare che TUTTI siano finiti prima di continuare; il mio codice:

import subprocess

#setup
do_setup()

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

#finish
do_finish()

Voglio correre tutto subprocess.call()allo stesso tempo, e poi aspettare che abbiano finito, come dovrei farlo?

Ho provato a utilizzare il threading come nell'esempio qui :

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()

Ma non credo che sia giusto.

Come faccio a sapere che hanno finito tutti di correre prima di andare al mio do_finish()?

È necessario utilizzare il metodo di unioneThread dell'oggetto alla fine dello 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()

Così il thread principale sarà aspettare fino t1, t2e t3terminare l'esecuzione.

Metti i thread in un elenco e quindi usa il metodo 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()

In Python3, a partire da Python 3.2 c'è un nuovo approccio per raggiungere lo stesso risultato, che personalmente preferisco al tradizionale thread creation / start / join, package concurrent.futures: https://docs.python.org/3/library/concurrent.futures .html

Utilizzando un ThreadPoolExecutorcodice sarebbe:

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')

L'output del codice precedente è qualcosa del tipo:

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

Uno dei vantaggi è che puoi controllare la velocità effettiva impostando il numero massimo di lavoratori simultanei.

Preferisco usare la comprensione dell'elenco basata su un elenco di input:

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]

Puoi avere una classe simile alla seguente dalla quale puoi aggiungere un numero 'n' di funzioni o console_scripts che desideri eseguire in parallelo, avviare l'esecuzione e attendere il completamento di tutti i lavori ..

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()

Dalla threading documentazione del modulo

C'è un oggetto "thread principale"; questo corrisponde al thread di controllo iniziale nel programma Python. Non è un thread daemon.

Esiste la possibilità che vengano creati "oggetti thread fittizi". Questi sono oggetti thread corrispondenti a "thread alieni", che sono thread di controllo avviati al di fuori del modulo di threading, ad esempio direttamente dal codice C. Gli oggetti thread fittizi hanno funzionalità limitate; sono sempre considerati vivi e demoniaci e non possono essere modificati join(). Non vengono mai cancellati, poiché è impossibile rilevare la terminazione di thread alieni.

Quindi, per catturare quei due casi in cui non sei interessato a mantenere un elenco dei thread che crei:

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

Al che:

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

Forse qualcosa di simile

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

Mi sono appena imbattuto nello stesso problema in cui dovevo aspettare tutti i thread che sono stati creati utilizzando il ciclo for. Ho appena provato il seguente pezzo di codice Potrebbe non essere la soluzione perfetta ma ho pensato che sarebbe stata una soluzione semplice testare:

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