Valeur de retour du thread

Si vous étiez en appelant join() pour attendre le thread pour terminer, vous pouvez simplement attacher le résultat au Fil de l'instance elle-même, puis de le récupérer à partir du thread principal après la jointure() retourne.

Sur l'autre main, vous ne nous dites pas comment vous avez l'intention de découvrir que le thread est fait et que le résultat est disponible. Si vous avez déjà un moyen de le faire, il sera probablement le point de vous (et nous, si vous nous le dire) à la meilleure façon d'obtenir les résultats.

Utilisation lambda pour envelopper votre cible en fonction de thread et de passer sa valeur de retour vers le parent fil à l'aide d'un file d'attente. (L'original de votre objectif reste inchangé, sans file d'attente paramètre.)

Exemple de code:

import threading
import queue
def dosomething(param):
    return param * 2
que = queue.Queue()
thr = threading.Thread(target = lambda q, arg : q.put(dosomething(arg)), args = (que, 2))
thr.start()
thr.join()
while not que.empty():
    print(que.get())

De sortie:

4

Une autre approche est de passer d'une fonction de rappel pour le thread. Cela donne un moyen simple, sûr et flexible pour renvoyer une valeur à la mère, à tout moment de la nouvelle thread.

# A sample implementation

import threading
import time

class MyThread(threading.Thread):
    def __init__(self, cb):
        threading.Thread.__init__(self)
        self.callback = cb

    def run(self):
        for i in range(10):
            self.callback(i)
            time.sleep(1)


# test

import sys

def count(x):
    print x
    sys.stdout.flush()

t = MyThread(count)
t.start()

POC:

import random
import threading

class myThread( threading.Thread ):
    def __init__( self, arr ):
        threading.Thread.__init__( self )
        self.arr = arr
        self.ret = None

    def run( self ):
        self.myJob( self.arr )

    def join( self ):
        threading.Thread.join( self )
        return self.ret

    def myJob( self, arr ):
        self.ret = sorted( self.arr )
        return

#Call the main method if run from the command line.
if __name__ == '__main__':
    N = 100

    arr = [ random.randint( 0, 100 ) for x in range( N ) ]
    th = myThread( arr )
    th.start( )
    sortedArr = th.join( )

    print "arr2: ", sortedArr

Basé sur jcomeau_ictx de la suggestion. Le plus simple je suis venu à travers. Exigence ici était d'obtenir le statut de sortie staus à partir de trois différents processus en cours d'exécution sur le serveur et de déclencher un autre script si tous les trois sont des succès. Cela semble fonctionner correctement

  class myThread(threading.Thread):
def __init__(self,threadID,pipePath,resDict):
threading.Thread.__init__(self)
self.threadID=threadID
self.pipePath=pipePath
self.resDict=resDict
def run(self):
print "Starting thread %s " % (self.threadID)
if not os.path.exists(self.pipePath):
os.mkfifo(self.pipePath)
pipe_fd = os.open(self.pipePath, os.O_RDWR | os.O_NONBLOCK )
with os.fdopen(pipe_fd) as pipe:
while True:
try:
message =  pipe.read()
if message:
print "Received: '%s'" % message
self.resDict['success']=message
break
except:
pass
tResSer={'success':'0'}
tResWeb={'success':'0'}
tResUisvc={'success':'0'}
threads = []
pipePathSer='/tmp/path1'
pipePathWeb='/tmp/path2'
pipePathUisvc='/tmp/path3'
th1=myThread(1,pipePathSer,tResSer)
th2=myThread(2,pipePathWeb,tResWeb)
th3=myThread(3,pipePathUisvc,tResUisvc)
th1.start()
th2.start()
th3.start()
threads.append(th1)
threads.append(th2)
threads.append(th3)
for t in threads:
print t.join()
print "Res: tResSer %s tResWeb %s tResUisvc %s" % (tResSer,tResWeb,tResUisvc)
# The above statement prints updated values which can then be further processed

Pour faciliter les programmes ci-dessus answeres ressembler un peu exagéré pour moi. Je voudrais fr-nicen la mutable approche:

class RetVal:
def __init__(self):
self.result = None
def threadfunc(retVal):
retVal.result = "your return value"
retVal = RetVal()
thread = Thread(target = threadfunc, args = (retVal))
thread.start()
thread.join()
print(retVal.result)