Création de threads en python

Question

J'ai un script et je veux qu'une fonction s'exécute en même temps que l'autre.

code exemple, j'ai regardé:

import threading 


def MyThread (threading.thread): 

    doing something........ 

def MyThread2 (threading.thread): 

    doing something........ 

MyThread().start() 
MyThread2().start() 

Je ne parviens pas à obtenir ce travail. Je préférerais que cela se passe en utilisant une fonction threadée plutôt qu'une classe.

Merci pour toute aide.

Ceci est le script de travail, Merci pour toute l'aide.

class myClass(): 

    def help(self): 

     os.system('./ssh.py') 

    def nope(self): 
     a = [1,2,3,4,5,6,67,78] 
     for i in a: 
      print i 
      sleep(1) 


if __name__ == "__main__": 
    Yep = myClass() 
    thread = Thread(target = Yep.help) 
    thread2 = Thread(target = Yep.nope) 
    thread.start() 
    thread2.start() 
    thread.join() 
    print 'Finished' 

Answer 1

Vous n'avez pas besoin d'utiliser une sous-classe de Thread pour faire ce travail - jeter un oeil à l'exemple simple que je poste ci-dessous pour voir comment:

from threading import Thread 
from time import sleep 

def threaded_function(arg): 
    for i in range(arg): 
     print "running" 
     sleep(1) 


if __name__ == "__main__": 
    thread = Thread(target = threaded_function, args = (10,)) 
    thread.start() 
    thread.join() 
    print "thread finished...exiting" 

Ici je montre comment utiliser la threading module pour créer un thread qui invoque une fonction normale comme cible. Vous pouvez voir comment je peux passer tous les arguments dont j'ai besoin dans le constructeur du thread.

Answer 2

Avez-vous remplacé la méthode run()? Si vous avez ignoré __init__, vous êtes-vous assuré d'appeler la base threading.Thread.__init__()? Après avoir démarré les deux threads, le thread principal continue-t-il de travailler indéfiniment/block/join sur les threads fils de sorte que l'exécution du thread principal ne se termine pas avant que les threads fils ne terminent leurs tâches?

Enfin, recevez-vous des exceptions non gérées?

Answer 3

Vous pouvez utiliser l'argument target dans le constructeur Thread pour transmettre directement une fonction appelée au lieu de run.

Answer 4

Il y a quelques problèmes avec votre code:

def MyThread (threading.thread): 

• Vous ne pouvez pas sous-classe avec une fonction; seulement avec une classe
• Si vous allez utiliser une sous-classe que vous voudriez threading.Thread, pas threading.thread

Si vous voulez vraiment faire cela avec des fonctions seulement, vous avez deux options:

Avec filetage:

import threading 
def MyThread1(): 
    pass 
def MyThread2(): 
    pass 

t1 = threading.Thread(target=MyThread1, args=[]) 
t2 = threading.Thread(target=MyThread2, args=[]) 
t1.start() 
t2.start() 

Avec fil:

import thread 
def MyThread1(): 
    pass 
def MyThread2(): 
    pass 

thread.start_new_thread(MyThread1,()) 
thread.start_new_thread(MyThread2,()) 

Doc pour thread.start_new_thread

Answer 5

J'ai essayé d'ajouter une autre jointure(), et cela semble fonctionner. Voici le code

from threading import Thread 
from time import sleep 

def function01(arg,name): 
for i in range(arg): 
    print(name,'i---->',i,'\n') 
    print (name,"arg---->",arg,'\n') 
    sleep(1) 


def test01(): 
    thread1 = Thread(target = function01, args = (10,'thread1',)) 
    thread1.start() 
    thread2 = Thread(target = function01, args = (10,'thread2',)) 
    thread2.start() 
    thread1.join() 
    thread2.join() 
    print ("thread finished...exiting") 



test01()