Multithreading in Python

Multithreading bezieht sich auf die Technik, mehrere Threads gleichzeitig innerhalb eines einzelnen Prozesses auszuführen. Die gleichzeitige Ausführung zielt darauf ab, das volle Potenzial von Computersystemen auszuschöpfen und Aufgaben noch schneller als gewöhnlich auszuführen.

Threads sind bemerkenswert leichtgewichtig und haben im Vergleich zu Prozessen einen geringen Speicherbedarf. Da sie sehr leicht sind, ist das Erstellen eines neuen Threads ein schneller Prozess. Laufende Threads erfordern weniger Systemressourcen, z. B. Arbeitsspeicher, um ausgeführt zu werden.

Da Threads Teil eines Prozesses sind, teilen sie sich den Speicherplatz mit ihrem übergeordneten Prozess oder dem Prozess, der sie erstellt hat. Multithreading mag zu beeindruckend erscheinen, aber nicht alles Glitzern ist Gold. Bei der Arbeit mit Threads muss man vorsichtig sein, da Deadlocks und Race Conditions ganz normal sind. Leider bieten von Python erstellte Threads aufgrund der GIL- oder Global Interpreter-Sperre in Python eine Verschachtelung und werden sequentiell, aber nicht parallel ausgeführt.

Man kann echte Parallelität mit Threads in anderen Programmiersprachen wie Java entdecken. Wenn man dennoch von mehreren CPU-Kernen mit Python profitieren muss, sollte man sich für Multiprocessing entscheiden (die Technik, verschiedene Prozesse parallel auszuführen).

Nichtsdestotrotz können wir in Python immer noch Multithreading in gewissem Umfang durchführen. In diesem Artikel lernen wir, wie man Multithreading mit Python durchführt.

Multithreading in Python

Wir können Pythons threading-Bibliothek verwenden, um Multithreading in Python durchzuführen. Es ist ein eingebautes Modul, das mit offiziellem Python vorinstalliert ist und darauf abzielt, Thread-basierte Parallelität in Python bereitzustellen. Um mehr über dieses Modul und seine Angebote zu erfahren, lesen Sie die offizielle Dokumentation hier.

Lassen Sie uns nun verstehen, wie diese Bibliothek zum Ausführen von Multithreading verwendet wird. Siehe dazu den folgenden Python-Code.

import threading


class MyThread(threading.Thread):
    def __init__(self, low, high):
        super(MyThread, self).__init__()
        self.low = low
        self.high = high
        self.total = 0

    def run(self):
        for x in range(self.low, self.high):
            self.total += x

    def __str__(self):
        return f"Low: {self.low} | High: {self.high}"


thread_one = MyThread(0, 500000)
thread_two = MyThread(5000000, 10000000)
thread_one.start()
thread_two.start()
thread_one.join()
thread_two.join()
result = thread_one.total + thread_two.total
print("Result:", result)

Ausgabe:

Result: 37624997250000

Das Modul threading stellt eine Klasse Thread bereit, die eine Aktion darstellt, die über einen separaten Thread ausgeführt wird. Eine Aktion kann alles sein, eine mathematische Berechnung, eine POST- oder GET-Anfrage an einen API-Endpunkt, das Abrufen einer Ausgabe von einem vortrainierten maschinellen Lernmodell, ein Teil einer umfangreichen Analyse usw.

Eine neue Klasse, die die Klasse Thread erbt, muss erstellt werden, genau wie die Klasse MyThread im obigen Python-Code. Als nächstes hat die Klasse Thread eine run()-Methode, die überschrieben werden muss. Diese Funktion enthält die eigentliche Aufgabe oder Berechnung, die der Thread bei Aktivierung ausführt.

Wie wir sehen können, haben wir die Funktion run() im obigen Python-Code überschrieben. Die obige Funktion run() läuft grundsätzlich in dem Bereich, der durch die Klassenattribute low und high definiert ist. Es addiert alle ganzen Zahlen innerhalb des Bereichs zu einem anderen Klassenattribut, total.

Nachdem wir nun mit einer kurzen Beschreibung der Klasse fertig sind, lassen Sie uns verstehen, wie das Programm funktioniert. Beziehen Sie sich auf die nächsten Schritte.

1. Zwei Threads, nämlich thread_one und thread_two, werden gespawnt oder erstellt.
2. Als nächstes wird die start()-Methode beider Threads aufgerufen. Die Methode start() führt die Methode run() für uns aus.
3. Als nächstes wird die Methode join() für beide Threads aufgerufen. Diese Methode stellt sicher, dass beide Threads aufeinander warten, bevor sie beendet werden. Nehmen wir an, der erste Thread hat seine Aufgabe 5 Sekunden vor dem zweiten Thread abgeschlossen. Wenn wir das Programm weiter ausführen lassen, werden wir auf seltsame Fehler stoßen, weil der zweite Thread immer noch nicht mit seiner Aufgabe fertig ist. Die Methode join() sorgt dafür, dass kein Thread beendet wird, bevor nicht alle anderen Threads mit ihren Aufgaben fertig sind.
4. Zuletzt werden die Ergebnisse beider Threads addiert und das Ergebnis auf der Konsole ausgegeben.

Beachten Sie, dass es zwingend erforderlich ist, dass ein aufgerufener Thread darauf wartet, dass andere Threads ihre Ausführung abschließen. Andernfalls kann es zu falschen Ergebnissen und Fehlern kommen.

Um mehr über die Klasse Thread zu erfahren, siehe die offizielle Dokumentation hier.