Comment puis-je invoquer un thread plusieurs fois en Python?

Question

Je suis désolé si c'est une question stupide. J'essaie d'utiliser un certain nombre de classes de multi-threading pour terminer différents travaux, ce qui implique d'invoquer ces multi-threads à des moments différents pour plusieurs fois. Mais je ne suis pas sûr de la méthode à utiliser. Le code ressemble à ceci:

class workers1(Thread): 
    def __init__(self): 
     Thread.__init__(self) 
    def run(self): 
     do some stuff 

class workers2(Thread): 
    def __init__(self): 
     Thread.__init__(self) 
    def run(self): 
     do some stuff 

class workers3(Thread): 
    def __init__(self): 
     Thread.__init__(self) 
    def run(self): 
     do some stuff 

WorkerList1=[workers1(i) for i in range(X)] 
WorkerList2=[workers2(i) for i in range(XX)] 
WorkerList2=[workers3(i) for i in range(XXX)] 


while True: 
    for thread in WorkerList1: 
     thread.run (start? join? or?) 
    for thread in WorkerList2: 
      thread.run (start? join? or?) 
    for thread in WorkerList3: 
      thread.run (start? join? or?) 
    do sth . 

Je suis en train d'avoir tous les fils dans tous les WorkerList pour commencer à fonctionner en même temps, ou tout au moins commencer dans le même temps. Après quelque temps, ils étaient tous terminés, je voudrais invoquer tous les fils à nouveau.

S'il n'y avait pas de boucle, je peux simplement utiliser .start; mais puisque je ne peux commencer un fil qu'une seule fois, commence apparemment ne correspond pas ici. Si j'utilise run, il semble que tous les threads démarrent séquentiellement, pas seulement les threads dans la même liste, mais aussi des threads provenant de différentes listes.

Quelqu'un peut-il aider s'il vous plaît?

Answer 1

il y a beaucoup d'idées fausses ici:

• vous ne pouvez démarrer une instance spécifique d'un fil une fois. mais dans votre cas, la boucle for boucle sur différentes instances d'un thread, chaque instance étant affectée à la variable thread dans la boucle, il n'y a donc aucun problème à appeler la méthode start() sur chaque thread. (Vous pouvez penser comme si la thread variable est un alias de l'objet Thread() instancié dans votre liste)

• run() n'est pas la même chose que join(): appeler run() Agit comme si vous étiez la programmation séquentielle. la méthode run() ne démarre pas un nouveau thread, il suffit d'exécuter les instructions dans la méthode, comme pour tout autre appel de fonction.

• ne commence pas à exécuter quoi que ce soit: il attend seulement la fin d'un thread. Pour que join() fonctionne correctement pour un thread, vous devez d'abord appeler start() sur ce fil.

En outre, vous ne devriez pas que vous ne pouvez pas redémarrer un fil une fois qu'il a terminé l'exécution: vous devez recréer l'objet de fil pour qu'il soit lancé à nouveau. une solution de contournement pour que cela fonctionne est d'appeler Thread.__init__() à la fin de la méthode run(). cependant, je ne recommanderais pas de le faire puisque cela interdira l'utilisation de la méthode join() pour détecter la fin de l'exécution du thread.

Answer 2

Si vous appelez thread.start() dans les boucles, vous souhaitez réellement commencer à chaque thread une seule fois, parce que toutes les entrées de la liste sont des objets de fil distincts (peu importe qu'ils appartiennent à la même classe). Vous ne devez jamais appeler directement la méthode run() d'un thread - elle doit être appelée par la méthode start(). L'appeler directement ne l'appelle pas dans un fil séparé.