Wie erhalte ich den Rückgabewert von einem Thread?

Die Funktion foo unten gibt eine Zeichenfolge zurück 'foo'. Wie bekomme ich den Wert 'foo' die vom Ziel des Threads zurückgegeben wird?

from threading import Thread

def foo(bar):
    print('hello {}'.format(bar))
    return 'foo'

thread = Thread(target=foo, args=('world!',))
thread.start()
return_value = thread.join()

Der oben gezeigte “eine offensichtliche Weg, dies zu tun” funktioniert nicht: thread.join() ist zurückgekommen None.

Eine Möglichkeit, die ich gesehen habe, besteht darin, ein änderbares Objekt, z. B. eine Liste oder ein Wörterbuch, zusammen mit einem Index oder einer anderen Kennung an den Konstruktor des Threads zu übergeben. Der Thread kann dann seine Ergebnisse in seinem dedizierten Slot in diesem Objekt speichern. Zum Beispiel:

def foo(bar, result, index):
    print 'hello {0}'.format(bar)
    result[index] = "foo"

from threading import Thread

threads = [None] * 10
results = [None] * 10

for i in range(len(threads)):
    threads[i] = Thread(target=foo, args=('world!', results, i))
    threads[i].start()

# do some other stuff

for i in range(len(threads)):
    threads[i].join()

print " ".join(results)  # what sound does a metasyntactic locomotive make?

Wenn du wirklich willst join() Um den Rückgabewert der aufgerufenen Funktion zurückzugeben, können Sie dies mit a tun Thread Unterklasse wie folgt:

from threading import Thread

def foo(bar):
    print 'hello {0}'.format(bar)
    return "foo"

class ThreadWithReturnValue(Thread):
    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs={}, Verbose=None):
        Thread.__init__(self, group, target, name, args, kwargs, Verbose)
        self._return = None
    def run(self):
        if self._Thread__target is not None:
            self._return = self._Thread__target(*self._Thread__args,
                                                **self._Thread__kwargs)
    def join(self):
        Thread.join(self)
        return self._return

twrv = ThreadWithReturnValue(target=foo, args=('world!',))

twrv.start()
print twrv.join()   # prints foo

Das wird wegen einiger Namensverstümmelungen etwas haarig und greift auf “private” Datenstrukturen zu, die spezifisch für sind Thread Umsetzung … aber es funktioniert.

Für Python3:

class ThreadWithReturnValue(Thread):
    
    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs={}, Verbose=None):
        Thread.__init__(self, group, target, name, args, kwargs)
        self._return = None

    def run(self):
        if self._target is not None:
            self._return = self._target(*self._args,
                                                **self._kwargs)
    def join(self, *args):
        Thread.join(self, *args)
        return self._return

FWIW, die multiprocessing Modul hat dafür eine nette Schnittstelle mit dem Pool Klasse. Und wenn Sie lieber bei Threads als bei Prozessen bleiben möchten, können Sie einfach die verwenden multiprocessing.pool.ThreadPool Klasse als Drop-in-Ersatz.

def foo(bar, baz):
  print 'hello {0}'.format(bar)
  return 'foo' + baz

from multiprocessing.pool import ThreadPool
pool = ThreadPool(processes=1)

async_result = pool.apply_async(foo, ('world', 'foo')) # tuple of args for foo

# do some other stuff in the main process

return_val = async_result.get()  # get the return value from your function.

In Python 3.2+ ist stdlib concurrent.futures Modul bietet eine API auf höherer Ebene threadingeinschließlich der Übergabe von Rückgabewerten oder Ausnahmen von einem Worker-Thread zurück an den Haupt-Thread:

import concurrent.futures

def foo(bar):
    print('hello {}'.format(bar))
    return 'foo'

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(foo, 'world!')
    return_value = future.result()
    print(return_value)

Jakes Antwort ist gut, aber wenn Sie keinen Threadpool verwenden möchten (Sie wissen nicht, wie viele Threads Sie benötigen, aber erstellen Sie sie nach Bedarf), dann ist das integrierte eine gute Möglichkeit, Informationen zwischen Threads zu übertragen Warteschlange.Warteschlange Klasse, da es Fadensicherheit bietet.

Ich habe den folgenden Decorator erstellt, damit er sich ähnlich wie der Threadpool verhält:

def threaded(f, daemon=False):
    import Queue

    def wrapped_f(q, *args, **kwargs):
        '''this function calls the decorated function and puts the 
        result in a queue'''
        ret = f(*args, **kwargs)
        q.put(ret)

    def wrap(*args, **kwargs):
        '''this is the function returned from the decorator. It fires off
        wrapped_f in a new thread and returns the thread object with
        the result queue attached'''

        q = Queue.Queue()

        t = threading.Thread(target=wrapped_f, args=(q,)+args, kwargs=kwargs)
        t.daemon = daemon
        t.start()
        t.result_queue = q        
        return t

    return wrap

Dann verwenden Sie es einfach als:

@threaded
def long_task(x):
    import time
    x = x + 5
    time.sleep(5)
    return x

# does not block, returns Thread object
y = long_task(10)
print y

# this blocks, waiting for the result
result = y.result_queue.get()
print result

Die dekorierte Funktion erstellt bei jedem Aufruf einen neuen Thread und gibt ein Thread-Objekt zurück, das die Warteschlange enthält, die das Ergebnis empfängt.

AKTUALISIEREN

Es ist schon eine ganze Weile her, dass ich diese Antwort gepostet habe, aber sie wird immer noch angesehen, also dachte ich, ich würde sie aktualisieren, um die Art und Weise widerzuspiegeln, wie ich dies in neueren Versionen von Python mache:

Python 3.2 hinzugefügt im concurrent.futures Modul, das eine High-Level-Schnittstelle für parallele Aufgaben bereitstellt. Es bietet ThreadPoolExecutor und ProcessPoolExecutorsodass Sie einen Thread oder Prozesspool mit derselben API verwenden können.

Ein Vorteil dieser API besteht darin, dass das Senden einer Aufgabe an eine Executor gibt a zurück Future -Objekt, das mit dem Rückgabewert des von Ihnen übermittelten Callable vervollständigt wird.

Dadurch wird das Anbringen a queue Objekt unnötig, was den Decorator ziemlich vereinfacht:

_DEFAULT_POOL = ThreadPoolExecutor()

def threadpool(f, executor=None):
    @wraps(f)
    def wrap(*args, **kwargs):
        return (executor or _DEFAULT_POOL).submit(f, *args, **kwargs)

    return wrap

Dies wird eine Standardeinstellung verwenden Modul Threadpool-Executor, wenn keiner übergeben wird.

Die Verwendung ist sehr ähnlich wie zuvor:

@threadpool
def long_task(x):
    import time
    x = x + 5
    time.sleep(5)
    return x

# does not block, returns Future object
y = long_task(10)
print y

# this blocks, waiting for the result
result = y.result()
print result

Wenn Sie Python 3.4+ verwenden, besteht ein wirklich nettes Feature bei der Verwendung dieser Methode (und von Future-Objekten im Allgemeinen) darin, dass die zurückgegebene Zukunft umschlossen werden kann, um sie in eine umzuwandeln asyncio.Future mit asyncio.wrap_future. Dadurch funktioniert es problemlos mit Coroutinen:

result = await asyncio.wrap_future(long_task(10))

Wenn Sie keinen Zugriff auf den Basiswert benötigen concurrent.Future -Objekt können Sie den Wrap in den Decorator einfügen:

_DEFAULT_POOL = ThreadPoolExecutor()

def threadpool(f, executor=None):
    @wraps(f)
    def wrap(*args, **kwargs):
        return asyncio.wrap_future((executor or _DEFAULT_POOL).submit(f, *args, **kwargs))

    return wrap

Wann immer Sie dann CPU-intensiven oder blockierenden Code aus dem Event-Loop-Thread verschieben müssen, können Sie ihn in eine dekorierte Funktion einfügen:

@threadpool
def some_long_calculation():
    ...

# this will suspend while the function is executed on a threadpool
result = await some_long_calculation()

Eine andere Lösung, die keine Änderung Ihres vorhandenen Codes erfordert:

import Queue             # Python 2.x
#from queue import Queue # Python 3.x

from threading import Thread

def foo(bar):
    print 'hello {0}'.format(bar)     # Python 2.x
    #print('hello {0}'.format(bar))   # Python 3.x
    return 'foo'

que = Queue.Queue()      # Python 2.x
#que = Queue()           # Python 3.x

t = Thread(target=lambda q, arg1: q.put(foo(arg1)), args=(que, 'world!'))
t.start()
t.join()
result = que.get()
print result             # Python 2.x
#print(result)           # Python 3.x

Es kann auch leicht an eine Multithread-Umgebung angepasst werden:

import Queue             # Python 2.x
#from queue import Queue # Python 3.x
from threading import Thread

def foo(bar):
    print 'hello {0}'.format(bar)     # Python 2.x
    #print('hello {0}'.format(bar))   # Python 3.x
    return 'foo'

que = Queue.Queue()      # Python 2.x
#que = Queue()           # Python 3.x

threads_list = list()

t = Thread(target=lambda q, arg1: q.put(foo(arg1)), args=(que, 'world!'))
t.start()
threads_list.append

# Add more threads here
...
threads_list.append(t2)
...
threads_list.append(t3)
...

# Join all the threads
for t in threads_list:
    t.join()

# Check thread's return value
while not que.empty():
    result = que.get()
    print result         # Python 2.x
    #print(result)       # Python 3.x

Die meisten Antworten, die ich gefunden habe, sind lang und erfordern die Vertrautheit mit anderen Modulen oder erweiterten Python-Funktionen und werden für jemanden ziemlich verwirrend sein, es sei denn, sie sind bereits mit allem vertraut, worüber die Antwort spricht.

Arbeitscode für einen vereinfachten Ansatz:

import threading

class ThreadWithResult(threading.Thread):
    def __init__(self, group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None):
        def function():
            self.result = target(*args, **kwargs)
        super().__init__(group=group, target=function, name=name, daemon=daemon)

Beispielcode:

import time, random


def function_to_thread(n):
    count = 0
    while count < 3:
            print(f'still running thread {n}')
            count +=1
            time.sleep(3)
    result = random.random()
    print(f'Return value of thread {n} should be: {result}')
    return result


def main():
    thread1 = ThreadWithResult(target=function_to_thread, args=(1,))
    thread2 = ThreadWithResult(target=function_to_thread, args=(2,))
    thread1.start()
    thread2.start()
    thread1.join()
    thread2.join()
    print(thread1.result)
    print(thread2.result)

main()

Erläuterung:
Ich wollte die Dinge erheblich vereinfachen, also habe ich eine erstellt ThreadWithResult Klasse und hatte es erben von threading.Thread. Die verschachtelte Funktion function in __init__ ruft die Thread-Funktion auf, deren Wert wir speichern möchten, und speichert das Ergebnis dieser verschachtelten Funktion als Instanzattribut self.result nachdem der Thread die Ausführung beendet hat.

Das Erstellen einer Instanz von this ist identisch mit dem Erstellen einer Instanz von threading.Thread. Übergeben Sie die Funktion, die Sie in einem neuen Thread ausführen möchten, an die target Argument und alle Argumente, die Ihre Funktion möglicherweise benötigt args -Argument und alle Schlüsselwortargumente für die kwargs Streit.

z.B

my_thread = ThreadWithResult(target=my_function, args=(arg1, arg2, arg3))

Ich denke, dies ist wesentlich einfacher zu verstehen als die überwiegende Mehrheit der Antworten, und dieser Ansatz erfordert keine zusätzlichen Importe! Ich habe die eingeschlossen time und random Modul, um das Verhalten eines Threads zu simulieren, aber sie sind nicht erforderlich, um die in der ursprünglichen Frage gestellte Funktionalität zu erreichen.

Ich weiß, ich beantworte diese Frage schon lange, nachdem die Frage gestellt wurde, aber ich hoffe, dass dies in Zukunft mehr Menschen helfen kann!

BEARBEITEN: Ich habe die erstellt save-thread-result PyPI-Paket damit Sie auf denselben Code oben zugreifen und ihn projektübergreifend wiederverwenden können (GitHub-Code ist hier). Das PyPI-Paket erweitert die threading.Thread Klasse, sodass Sie alle Attribute festlegen können, die Sie festlegen würden threading.thread auf der ThreadWithResult Klasse auch!

Die ursprüngliche Antwort oben geht auf die Hauptidee hinter dieser Unterklasse ein, aber für weitere Informationen siehe die genauere Erklärung (aus dem Modul docstring) hier.

Schnelles Anwendungsbeispiel:

pip3 install -U save-thread-result     # MacOS/Linux
pip  install -U save-thread-result     # Windows

python3     # MacOS/Linux
python      # Windows

from save_thread_result import ThreadWithResult

# As of Release 0.0.3, you can also specify values for
#`group`, `name`, and `daemon` if you want to set those
# values manually.
thread = ThreadWithResult(
    target = my_function,
    args   = (my_function_arg1, my_function_arg2, ...)
    kwargs = {my_function_kwarg1: kwarg1_value, my_function_kwarg2: kwarg2_value, ...}
)

thread.start()
thread.join()
if getattr(thread, 'result', None):
    print(thread.result)
else:
    # thread.result attribute not set - something caused
    # the thread to terminate BEFORE the thread finished
    # executing the function passed in through the
    # `target` argument
    print('ERROR! Something went wrong while executing this thread, and the function you passed in did NOT complete!!')

# seeing help about the class and information about the threading.Thread super class methods and attributes available:
help(ThreadWithResult)

Parris / Kindalls Antwort join/return Antwort auf Python 3 portiert:

from threading import Thread

def foo(bar):
    print('hello {0}'.format(bar))
    return "foo"

class ThreadWithReturnValue(Thread):
    def __init__(self, group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None):
        Thread.__init__(self, group, target, name, args, kwargs, daemon=daemon)

        self._return = None

    def run(self):
        if self._target is not None:
            self._return = self._target(*self._args, **self._kwargs)

    def join(self):
        Thread.join(self)
        return self._return


twrv = ThreadWithReturnValue(target=foo, args=('world!',))

twrv.start()
print(twrv.join())   # prints foo

Beachten Sie das Thread -Klasse ist in Python 3 anders implementiert.