Holen Sie sich einen Rückgabewert von einem Thread in Python

1. HelloWorld-Programm, das Multi-Threading in Python verwendet
2. Holen Sie sich einen Rückgabewert von einer Funktion, die in Thread in Python ausgeführt wird

In diesem Artikel werden zunächst die Thread-Grundlagen und ein Code zum Starten eines Threads in Python erläutert. Danach besprechen wir einen Code, um die Wertrückgabe von einer Funktion zu erhalten, die in einem Thread ausgeführt wird.

Ein Thread ist eine leichtgewichtige Ausführungseinheit innerhalb eines Prozesses mit eigenen Programmausführungszuständen. Ein Prozess führt mehrere Threads aus, um Parallelität (und manchmal Parallelität) zu erreichen.

Der Hauptunterschied zwischen einem Prozess und einem Thread besteht darin, dass jeder Prozess einen separaten disjunkten Adressraum hat, während mehrere Threads desselben Prozesses denselben Adressraum eines einzelnen Prozesses gemeinsam nutzen. Dies bedeutet, dass die Threads unter Verwendung des gemeinsam genutzten Speichers kommunizieren können, ohne dass zusätzliche Pipes (Ordinary Pipes oder FIFOs) oder eine Message-Passing-Schnittstelle erforderlich sind.

HelloWorld-Programm, das Multi-Threading in Python verwendet

Betrachten Sie den folgenden Code:

from threading import Thread

# A function for threads.


def first_function():
    print("Hello World")


print("main program start")

thread_1 = Thread(target=first_function)
thread_2 = Thread(target=first_function)
thread_1.start()
thread_2.start()

print("main ends")

Im obigen Code haben wir zuerst die Anweisung from threading import Thread verwendet, um die Klasse Thread zu importieren, um das Multi-Threading zu verwenden. Wir haben eine Funktion first_function() definiert, die Hello World anzeigt, und die Klasse Thread() verwendet, um die Threads zu instanziieren.

Wir haben zwei Instanzen der Klasse Thread() erstellt, indem wir die first_function() als auszuführende target-Funktion übergeben haben. Das Attribut target spezifiziert die vom Thread() auszuführende Funktion.

Sobald die Thread()-Instanzen erstellt sind, können wir diese Threads mit der .start()-Methode ausführen und ausführen.

Übergeben Sie Argumente an eine Funktion, die im Thread ausgeführt wird

Betrachten Sie den folgenden Code:

from threading import Thread


def first_function(name, id):
    print("Hello World from ", name, " ID= ", id)


thread_1 = Thread(target=first_function, args=("Thread 1", 1))
thread_2 = Thread(target=first_function, args=("Thread 2", 2))
thread_1.start()
thread_2.start()

Im obigen Code haben wir die Funktion first_function(name, id) definiert und zwei Argumente empfangen, name und id. Wir haben diese Argumente als Tupel mit args in der Klasse Thread übergeben.

Wir haben zwei Thread-Klassenobjekte erstellt und die Argumente args=("Thread 1", 1) und args=("Thread 2", 2) jeweils an thread_1 und thread_2 übergeben. Außerdem werden thread_1.start() und thread_2.start() verwendet, um diese Threads auszuführen.

Holen Sie sich einen Rückgabewert von einer Funktion, die in Thread in Python ausgeführt wird

Es gibt verschiedene Möglichkeiten, einen Rückgabewert von einer Funktion zu erhalten, die in einem Thread ausgeführt wird.

Übergeben Sie ein veränderliches Objekt an die Funktion

Wir können einen Wert von einer Funktion erhalten, die in einem Thread ausgeführt wird, indem wir ein veränderliches Objekt an die Funktion übergeben; Die Funktion platziert den Rückgabewert in diesem Objekt. Betrachten Sie den folgenden Code:

from threading import Thread


def first_function(first_argu, return_val):
    print(first_argu)
    return_val[0] = "Return Value from " + first_argu


return_val_from_1 = [None] * 1
return_val_from_2 = [None] * 1

thread_1 = Thread(target=first_function, args=("Thread 1", return_val_from_1))
thread_2 = Thread(target=first_function, args=("Thread 2", return_val_from_2))

thread_1.start()
thread_2.start()

thread_1.join()
thread_2.join()

print(return_val_from_1)
print(return_val_from_2)

Der obige Code definiert eine Funktion first_function, die zwei Argumente erhält: first_argu und return_val. Die first_function zeigt den Wert von first_argu an und platziert den Rückgabewert in den 0-Indizes von return_val.

Wir erstellen einen Thread mit der Klasse Thread und übergeben zwei Argumente, darunter eine Liste args=("Thread 1", return_val_from_1) und args=("Thread 2", return_val_from_2) für thread_1 bzw. thread_2. return_val_from_1 und return_val_from_2 werden verwendet, um einen Wert von der Funktion zu erhalten.

thread_1.join() und thread_2.join() werden verwendet, um darauf zu warten, dass das Hauptprogramm beide Threads beendet.

Schauen wir uns die Ausgabe für das obige Code-Snippet an:

Verwenden Sie die join-Methode

Die Methode join ist eine weitere Möglichkeit, einen Rückgabewert von einer Funktion zu erhalten, die in einem Thread ausgeführt wird. Betrachten Sie den folgenden Code:

from threading import Thread


def first_function(first_argu):
    print(first_argu)
    return "Return Value from " + first_argu


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

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

    def join(self, *args):
        Thread.join(self, *args)
        return self._return


thread_1 = NewThread(target=first_function, args=("Thread 1",))
thread_2 = NewThread(target=first_function, args=("Thread 2",))

thread_1.start()
thread_2.start()

print(thread_1.join())
print(thread_2.join())

Im obigen Code definieren wir eine angepasste Klasse, NewThread, eine Unterklasse der Thread-Klasse. Wir definieren die Methoden run und join neu.

Sobald wir einen Thread erstellt und gestartet haben, wird der Rückgabewert von first_function von der Methode join() zurückgegeben.

Die Ausgabe des folgenden Codes lautet wie folgt: