Python Multithreading

„In einem Prozess wird eine Ausführungseinheit als Thread bezeichnet. Durch schnelles Verschieben der Aufmerksamkeit der CPU zwischen Threads können zahlreiche Threads gleichzeitig in einem als Multithreading bezeichneten Prozess ausgeführt werden (auch als Kontextschalter bezeichnet). Die Grundlagen von Python Multithreading werden in diesem Artikel behandelt. Für Ihre Hilfe werden wir auch eine Vielzahl von Beispielen angeben.”

Multithreading in Python

Multithreading ist eine Threading -Technik, die in der Python -Programmierung verwendet wird, um viele Threads gleichzeitig auszuführen. Darüber hinaus ermöglicht es die Freigabe seines Datenraums mit den primären Themen innerhalb eines Prozesses, die Informationen leichter kommunizieren und freigeben als separate Prozesse. Das Ziel des Multithreading ist es, zahlreiche Prozesse gleichzeitig durchzuführen, was das Rendering und die Leistung der Anwendung verbessert.

Es ist eine sehr praktische Methode, um die Funktionalität einer Anwendung zu beschleunigen und zu verbessern. Durch die Verwendung von Multithreading kann ein Programmierer die Anwendungsaufgaben in kleinere Jobs zerlegen und mehrere Instanzen des Programms gleichzeitig ausführen. Es ermöglicht Threads, miteinander zu kommunizieren und Prozessorressourcen wie Speicher, Dateien und Daten freizugeben. Darüber hinaus macht es die Benutzer eher bereit, ein Programm weiterhin zu verwenden, auch wenn ein Abschnitt davon blockiert oder zu lang ist.

Beispiel 1

Hier ist ein einfaches Python -Programm für Multithreading. Schauen wir uns ein Python -Programm mit zwei Klassen an, "Python_demo" und "Python_lesson".Schauen wir uns diesen Beispielcode im Detail an.

Zwei unserer Klassen verwenden ähnliche Techniken. Die Ausgabe der Lauffunktion des Objekts der ersten Klasse, wenn sie konstruiert wird, und drucken Sie den Ausdruck „Python -Demo“ viermal. Das Wort „Python -Lektion“ erscheint viermal, wenn wir den Vorgang für die zweite Klasse wiederholen.

Klasse python_demo:
def run (self):
für i in Reichweite (4):
print ("Python -Demo")
Klasse Python_lesson:
def run (self):
für i in Reichweite (4):
print ("Python -Lektion")
First_obj = Python_demo ())
Second_obj = Python_lesson ()
First_obj.laufen()
Second_obj.laufen()

Das Ergebnis, wenn wir dieses Programm ausführen, ist wie folgt. Python Demo und Python -Lektion werden viermal nacheinander angezeigt, wie Sie sehen können. Infolgedessen läuft in dem Haupt -Thread dieses Programm. Jedes Programm enthält den Hauptfaden. In diesem Fall werden beide Operationen in einer Sequenz durchgeführt.

Beispiel 2

Wir werden Pythons Threading -Modul als Beispiel einsetzen. Wir könnten die Notwendigkeit des Multithreading verstehen, wenn wir das erste Szenario berücksichtigen. Dies impliziert, dass beide Verfahren gleichzeitig verwendet werden müssen. Pythons Thread -Klasse und Threading -Paket können verwendet werden, um dies zu erreichen. Versuchen wir, an etwas zu denken. Nachdem Multithreading vorhanden ist, wurde das Beispielprogramm aktualisiert. Zusätzlich wurde jede Klasse als eigener Thread mit der Thread -Klasse ausgeführt.

Wir haben auch einen Unterschied gemacht, indem wir die Run -Methode nicht direkt aufgerufen haben. Stattdessen verwenden wir die Startmethode, die im Grunde der Mechanismus der Threading -Implementierung ist.

Wenn wir die Startmethode anwenden, wird die Auslauffunktion sofort im Hintergrund aufgerufen. Derzeit führen wir den Haupt Thread standardmäßig aus. Zwei Kinderfäden, erste OBJ und zweite OBJ, werden gebildet, wenn die Startmethoden aufgerufen werden.

vom Threading -Import *
Klasse Python_demo (Thread):
def run (self):
für i in Reichweite (4):
print ("Python -Demo")
Klasse Python_lesson (Thread):
def run (self):
für i in Reichweite (4):
print ("Python -Lektion")
First_obj = Python_demo ())
Second_obj = Python_lesson ()
First_obj.Start()
Second_obj.Start()

Diese Anpassungen führen zu dem unten angezeigten Ausgang, der unten angezeigt wird. Nachdem die Anwendung ausgeführt wird, kann Multithreading als stattfinden. Wir sehen. Dies resultierte aus einer Kollision. Dies geschieht aufgrund von zwei Threads (First_obj und Second_OBJ), die versuchen, aufgrund der übermäßigen Geschwindigkeit des Prozessors gleichzeitig auf der CPU auszuführen.

Beispiel 3

Scheduler im Betriebssystem geben die Zeit für die Ausführung an. In diesem Beispiel werden die Anweisungen von der Software mehr als einmal zu einem bestimmten Zeitpunkt durchgeführt.

Wir können dies verhindern, indem wir den Schlafansatz verwenden, um unserer Software eine geringe Verzögerung zu bieten. Um dies zu erreichen, müssen wir die Schlaffunktion aus dem Zeitmodul importieren, um eine kurze Pause zwischen der Ausführung der beiden Threads hinzuzufügen. Mit Ausnahme der Hinzufügung der Schlaffunktion ist der Code praktisch identisch mit den Beispielen von zuvor.

Beachten Sie die erforderlichen Module, Fädeln und Schlaf. Diese Module werden zuerst importiert. Die Schlaffunktion wird dann in zwei Klassen ausgeführt, die später konstruiert werden. Um den Satz eine bestimmte Anzahl von Zeiten in unserem Fall zu drucken. Um die Anwendung auszuführen, haben wir die Start () -Methode nach dem Implementieren des Threading -Ansatzes aufgerufen. Die letzten Codezeilen des Programms zeigen dies.

vom Threading -Import *
Zum Zeitpunkt des Imports
Klasse Python_demo (Thread):
def run (self):
für i in Reichweite (3):
print ("Python -Demo")
Schlaf (1)
Klasse Python_lesson (Thread):
def run (self):
für i in Reichweite (3):
print ("Python -Lektion")
Schlaf (1)
First_obj = Python_demo ())
Second_obj = Python_lesson ()
First_obj.Start()
Schlaf (0.3)
Second_obj.Start()

Das Ergebnis zeigt nun, dass die Threads gleichzeitig ausgeführt werden.

Beispiel 4

Das Threading -Modul in Python wird verwendet, um Threads im folgenden Code -Snippet zu konstruieren. Der Haupt -Thread wird im Code ausgeführt, und die Wörter "Dies ist der Haupt -Thread" werden gedruckt. Der erste Thread und der zweite Thread sind zwei neu etablierte und laufende Threads. Es gibt einen Kontextübergang, und der erste Thread beginnt zu laufen.

Der erste Thread geht nach den ersten vier Iterationen ein.

Die CPU steht nun unter der Kontrolle des Hauptfadens, der „Hauptfaden wieder!”

Der zweite Thread setzt seine Ausführung nach einem weiteren Kontextschalter wieder und schließt ab. Der Haupt -Thread kann keine weiteren Anweisungen mehr ausführen. Daher endet das Programm.

Threading als TD importieren
Zeit als t importieren
Def print_welcome ():
für i in Reichweite (5):
Wenn ich == 4:
T.Schlaf (2)
print ("willkommen")
Def print_integers (n):
für i im Bereich (n+1):
drucken (i)
drucken ("Dies ist der Hauptfaden."))
First_Thread = td.Thread (Ziel = print_welcome, args = ())
Second_Thread = td.Thread (Ziel = print_integers, args = (10,))
First_Thread.Start()
Second_Thread.Start()
Drucken ("Hauptfaden wieder!"))

Sie können die Ausgabe in diesem Abschnitt sehen, in dem der Haupt -Thread zuerst ausgeführt wird und die Nachricht bei Bedarf wiederholt wird. Nach der Ausführung des zweiten Threads, in dem die Nummern angezeigt wurden, kehrte die Software zum ersten Thread zurück und führte die Funktion aus, die das Wort „Willkommen“ zeigt.”

Abschluss

Das Thema dieses Artikels war Python Multithreading. Durch schnelles Umschalten zwischen den Gewinnen mit einer CPU ist Multithreading eine Threading -Technik, die in der Python -Programmierung verwendet wird, um viele Threads gleichzeitig auszuführen. Darüber hinaus ermöglicht es die Freigabe seines Datenraums mit den primären Themen innerhalb eines Prozesses, die Informationen leichter kommunizieren und freigeben als separate Prozesse. Das Ziel des Multithreading ist es, zahlreiche Prozesse gleichzeitig durchzuführen.