Parallelität in Python

| | ,

Home » Parallelität in Python

In den meisten Informatikkursen werden Multithreading und Nebenläufigkeit in Python in den Backend-Vorlesungen oder sogar in geringerem Umfang in den Betriebssystemen gelehrt. Dies führt dazu, dass die meisten Informatik-Absolventen beim Versuch, parallele Programme zu schreiben, ratlos sind. Mit dem Aufkommen von Web 2.0 haben Parallelität und Multithreading jedoch viel an Dynamik gewonnen und Parallelität ist heute wichtiger denn je. Dieser Blog befasst sich mit Multithreading und Parallelität in Python. Um Multithreading zu verstehen, müssen wir zuerst den Thread verstehen.

Was ist ein Thread?

In der Computerprogrammierung sind Threads leichtgewichtige Prozesse, die sicherstellen, dass jeder Prozessor seine Aufgaben separat auf dem System ausführt. Stellen Sie sich einen Thread als einen Ausführungsfluss vor und jeder Thread kann seine eigene separate Reihenfolge von Anweisungen ausführen. Wenn wir den Prozess des Multithreading verwenden, können wir unser Programm verschiedene Teile seines Programms zu unterschiedlichen Zeiten ausführen lassen, die alle gleichzeitig ausgeführt werden, aber nicht wirklich parallel. Jeder Thread läuft abwechselnd, um Parallelität zu erreichen. Dies liegt an einer Funktion namens GIL (Global Interpreter Lock), was bedeutet, dass nur ein Thread gleichzeitig ausgeführt werden kann, aber alle abwechselnd laufen können, wenn ein Thread inaktiv ist, sodass sie gleichzeitig ausgeführt werden nicht wirklich parallel. Programmierer verwenden Python 3 gerne wegen seiner Multi-Threading-Fähigkeiten – dies ermöglicht es mehreren Prozessoren, gleichzeitig zu laufen und Aufgaben im Namen eines Programms auszuführen.

Programme und Aufgaben lassen sich in zwei verschiedene Kategorien einteilen:

CPU-gebunden: Es ist ein Programm oder eine Aufgabe, die die meiste Zeit damit verbringt, auf interne Ereignisse zu warten, wie z. B. eine CPU-intensive Aufgabe. Es ist besser, Multi-Processing für die CPU-gebundenen Aufgaben zu verwenden.

E/A-gebunden: Es ist ein Aufgabenprogramm, das die meiste Zeit damit verbringt, auf externe Ereignisse zu warten, z kann mehrere Threads gleichzeitig laufen lassen, aber nicht wirklich parallel.

Wie verwende ich MultiThreading in Python?

Für die Verwendung von Multithreading in Python gibt es zwei Hauptmodule, die beim Umgang mit Threads verwendet werden.

Das Thread-Modul:

Das Thread-Modul kann beim Low-Level-Threading effektiv sein, es gibt ein Modul, das alles macht, was das Thread-Modul tut und mehr. Dieses Modul ist das neuere Threading-Modul.

Das Einfädelmodul:

Das Threading-Modul ist eine High-Level-Implementierung mehrerer Threads, die in Python oder Parallelität in Python verwendet werden. Sein Hauptziel besteht darin, Entwicklern zu ermöglichen, mehrere Threads innerhalb desselben Programms auf einem einzigen Computer zu erstellen, zu konfigurieren und zu verwenden, auf dem der Python-Interpreter ausgeführt wird.

Liste einiger nützlicher Funktionen, die im Threading-Modul definiert sind:

  • activeCount() – Gibt die Anzahl der aktiven Thread-Objekte zurück, die verwendet werden.
  • currentThread() – Gibt das aktuelle Objekt der Thread-Klasse zurück.
  • enumerate() Rückgabe Liste aller aktiven Thread-Objekte.

Liste einiger nützlicher Methoden der Thread-Klasse, die im Threading-Modul definiert sind:

  • start() – Die Methode start startet einen neuen Thread, indem sie die Methode run() aufruft.
  • run() – Die Methode run wird verwendet, um die Aktivität eines Threads anzuzeigen und kann von einer Klasse überschrieben werden, die die Klasse Thread erweitert.
  • join() –  Eine Join-Methode wird verwendet, um die Ausführung von anderem Code zu blockieren, bis der Thread geschlossen wird.

Hier ist ein einfaches Beispiel für das Threading-Modul. Dadurch wird die Anzahl der Threads gezählt, die derzeit im Hintergrund ausgeführt werden.

#importing the threading and time module
import threading
import time

print(threading.active_count())
print(threading. enumerate())

Ausgabe:

Immer wenn wir das Programm ausführen und ein Thread läuft, der für die Ausführung unseres Programms verantwortlich ist, können wir die aktive Anzahl des Threads sehen, der im Hintergrund läuft. In der zweiten Zeile sehen wir eine Liste aller laufenden Threads und der Haupt-Thread ist hier für die Ausführung unseres Programms verantwortlich. Mit dem Konzept der Parallelität in Python können wir mehr als einen Thread gleichzeitig ausführen, aber nicht wirklich parallel zu.

Erreichen von MultiThreading mit dem Python-Threading-Modul:

Lassen Sie uns zunächst ein einfaches Programm erstellen, das wir für Multithreading verwenden können.

#importing the threading and time module
import threading
import time

#creating task one
def Task_one():
    time.sleep(3)
    print("Task one completed")

#creating task two
def Task_two():
    time.sleep(4)
    print("Task two completed")

#creating task three
def Task_three():
    time.sleep(5)
    print("Task three completed")

t = time.time() 
#calling all the function in main thread
Task_one()
Task_two()
Task_three()

print(" Active count of the threads :",threading.active_count())
print(" list of running threads :",threading.enumerate())
print(" Time taken to complete :", time.time() - t) 

Ausgabe:

Die Ausführung dieses Programms dauert etwa 12 Sekunden, da alle Programme in einem einzigen Thread ausgeführt werden. Aus diesem Grund werden ihre Aufgaben sequentiell und nicht gleichzeitig ausgeführt, so dass die Beendigung einer Aufgabe die Beendigung einer anderen erfordert, bevor eine andere beginnen kann.

Hinzufügen von MultiThreading-Funktionen im Programm mit dem Python-Threading-Modul:

#importing the threading and time module
import threading
import time

#creating task one
def Task_one():
    time.sleep(3)
    print("Task one complete")

#creating task two
def Task_two():
    time.sleep(4)
    print("Task two complete")

#creating task three
def Task_three():
    time.sleep(5)
    print("Task three complete")

#creating new thread for task one
x = threading.Thread(target=Task_one, args=())
x.start()

#creating new thread for task two
y = threading.Thread(target=Task_two, args=())
y.start()

#creating new thread for task three
z = threading.Thread(target=Task_three, args=())
z.start()

# getting total time to run the functions 
t = time.time()

#print the active count using active count function available in the threading module
print(" Active count of the threads :",threading.active_count())
#print the list of all of the threads that are running using the enumerate function
print(" list of running threads:",threading.enumerate()) print(" Time taken to complete:", time.time() - t) 

Ausgabe:

Jetzt werden vier Threads für diese Aufgabe ausgeführt und die Ausführung dauert weniger als fünf Sekunden. Da wir für jede dieser Aufgaben einen eigenen Thread haben, können wir alle vier gleichzeitig ausführen, anstatt nur einen, nachdem der vorherige abgeschlossen ist. Und Sie haben vielleicht bemerkt, dass die aktive Zähl- und Aufzählungsfunktion aufgerufen wird, bevor unsere drei Funktionen ihre jeweiligen Aufgaben abgeschlossen haben nicht mehr für diese Funktionen verantwortlich und dies ist auch der Grund, warum die Gesamtzeit der Threads sehr gering ist (0,0009970664978027344).

Synchronisieren von Threads:

Beim Synchronisieren von Threads können wir einen aufrufenden Thread haben. In diesem Fall wartet unser Hauptthread, bis ein anderer Thread fertig ist, bevor er mit seiner eigenen Anweisung fortfahren kann.

# here we synchronized thread x, y, and z using the join function  
x.join()
y.join()
z.join()

Nach dem Hinzufügen der Join-Funktion im Code sollte Ihre Ausgabe so aussehen:

Ausgabe:

In dieser Ausgabe können Sie sehen, wie unsere Funktionen zuerst abgeschlossen wurden und die Gesamtanzahl der aktiven Aktivitäten nur 1 beträgt, da die Threads synchronisiert sind und die Zeit zum Ausführen der Aufgabe ungefähr fünf Sekunden beträgt.

Letzte Worte

MultiThreading ist nichts anderes als die Fähigkeit eines Programms, mehrere Aufgaben gleichzeitig auszuführen. Durch die Verwendung eines Threading-Moduls können Sie Threads in Python erstellen und auf freigegebene Variablen von mehreren Threads im selben Prozess zugreifen. Ich hoffe, dass dieses Tutorial Ihnen ein grundlegendes Verständnis der Verwendung des Multithreading-Moduls in Python vermittelt. Wenn Sie Fragen/Anmerkungen zu diesem Prozess haben. Fühlen Sie sich frei zu kommentieren Happy Coding!

Hier sind einige nützliche Tutorials, die Sie lesen können:

Spread the love
 
   
Vorheriger

Echtzeit-Zwischenflussschätzung für die Videoframe-Interpolation mit Python

Konvertieren in 8-Bit-Bilder mit Python

Nächster

Schreibe einen Kommentar