multithreading python attendez que tous les threads soient terminés

Cela a peut-être été demandé dans un contexte similaire, mais je n'ai pas pu trouver de réponse après environ 20 minutes de recherche, je vais donc demander.

J'ai écrit un script Python (disons: scriptA.py) et un script (disons scriptB.py)

Dans scriptB, je veux appeler scriptA plusieurs fois avec des arguments différents, chaque fois prend environ une heure à exécuter, (c'est un énorme script, fait beaucoup de choses ... ne vous inquiétez pas) et je veux pouvoir exécuter le scriptA avec tous les différents arguments simultanément, mais je dois attendre que TOUS soient terminés avant de continuer; mon code:

import subprocess

#setup
do_setup()

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

#finish
do_finish()

Je veux tout exécuter subprocess.call()en même temps, puis attendre qu'ils soient tous terminés, comment dois-je faire cela?

J'ai essayé d'utiliser le filetage comme l'exemple ici :

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

Mais je ne pense pas que ce soit juste.

Comment puis-je savoir qu'ils ont tous fini de courir avant d'accéder à mon do_finish()?

Vous devez utiliser la méthode de jointure de l' Threadobjet à la fin du 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()

Ainsi , le fil conducteur attendra jusqu'à ce que t1, t2et t3terminer l' exécution.

Mettez les threads dans une liste, puis utilisez la méthode 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, depuis Python 3.2 , il est une nouvelle approche pour atteindre le même résultat, que je préfère personnellement à la création de fil traditionnelle / start / join, package concurrent.futures: https://docs.python.org/3/library/concurrent.futures .html

Utiliser un ThreadPoolExecutorcode serait:

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 sortie du code précédent est quelque chose comme:

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

L'un des avantages est que vous pouvez contrôler le débit en définissant le nombre maximal de nœuds de calcul simultanés.

Je préfère utiliser la compréhension de liste basée sur une liste d'entrée:

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]

Vous pouvez avoir une classe quelque chose comme ci-dessous à partir de laquelle vous pouvez ajouter un nombre 'n' de fonctions ou de console_scripts que vous souhaitez exécuter en parallèle avec passion et démarrer l'exécution et attendre que tous les travaux soient terminés.

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

À partir de la documentation du threading module

Il y a un objet «thread principal»; cela correspond au thread de contrôle initial dans le programme Python. Ce n'est pas un thread démon.

Il est possible que des «objets thread factices» soient créés. Ce sont des objets threads correspondant à des «threads étrangers», qui sont des threads de contrôle démarrés en dehors du module de threading, comme directement à partir du code C. Les objets thread factices ont des fonctionnalités limitées; ils sont toujours considérés comme vivants et démoniaques et ne peuvent pas être join()édités. Ils ne sont jamais supprimés, car il est impossible de détecter la fin des threads étrangers.

Donc, pour attraper ces deux cas où vous n'êtes pas intéressé à conserver une liste des threads que vous créez:

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

Après quoi:

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

Peut-être, quelque chose comme

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

Je viens de rencontrer le même problème où je devais attendre tous les threads créés à l'aide de la boucle for.Je viens d'essayer le morceau de code suivant.Ce n'est peut-être pas la solution parfaite mais je pensais que ce serait une solution simple tester:

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