Multithreading in Python mit Beispiel:Lernen Sie GIL in Python

Ein Philosoph muss zu jeder Zeit entweder essen oder denken.

Außerdem muss ein Philosoph die zwei Gabeln neben sich nehmen (d. h. die linke und die rechte Gabel), bevor er die Spaghetti essen kann. Das Problem des Deadlocks tritt auf, wenn alle fünf Philosophen gleichzeitig ihre rechte Gabel in die Hand nehmen.

Da jeder der Philosophen eine Gabel hat, werden sie alle warten, bis die anderen ihre Gabel weglegen. Folglich wird keiner von ihnen Spaghetti essen können.

In ähnlicher Weise tritt in einem nebenläufigen System ein Deadlock auf, wenn verschiedene Threads oder Prozesse (Philosophen) gleichzeitig versuchen, die gemeinsam genutzten Systemressourcen (Forks) zu erwerben. Infolgedessen hat keiner der Prozesse die Möglichkeit, ausgeführt zu werden, da sie auf eine andere Ressource warten, die von einem anderen Prozess gehalten wird.

Rennbedingungen

Eine Wettlaufbedingung ist ein unerwünschter Zustand eines Programms, der auftritt, wenn ein System zwei oder mehr Operationen gleichzeitig ausführt. Betrachten Sie zum Beispiel diese einfache for-Schleife:

i=0; # a global variable
for x in range(100):
    print(i)
    i+=1;

Wenn Sie n erstellen Anzahl der Threads, die diesen Code gleichzeitig ausführen, können Sie den Wert von i (der von den Threads geteilt wird) nicht bestimmen, wenn das Programm die Ausführung beendet. Dies liegt daran, dass sich in einer echten Multithreading-Umgebung die Threads überlappen können und der Wert von i, der von einem Thread abgerufen und modifiziert wurde, sich zwischendurch ändern kann, wenn ein anderer Thread darauf zugreift.

Dies sind die beiden Hauptklassen von Problemen, die in einer Multithread- oder verteilten Python-Anwendung auftreten können. Im nächsten Abschnitt erfahren Sie, wie Sie dieses Problem durch Synchronisieren von Threads lösen können.

Synchronisieren von Threads

Um Racebedingungen, Deadlocks und andere Thread-basierte Probleme zu bewältigen, stellt das Threading-Modul die Sperre bereit Objekt. Die Idee ist, dass ein Thread, wenn er auf eine bestimmte Ressource zugreifen möchte, eine Sperre für diese Ressource erwirbt. Sobald ein Thread eine bestimmte Ressource sperrt, kann kein anderer Thread darauf zugreifen, bis die Sperre aufgehoben wird. Als Ergebnis werden die Änderungen an der Ressource atomar sein und Race Conditions werden abgewendet.

Eine Sperre ist ein einfaches Synchronisationselement, das vom __thread implementiert wird Modul. Eine Sperre kann sich jederzeit in einem von zwei Zuständen befinden:gesperrt oder entsperrt. Es unterstützt zwei Methoden:

1. erwerben() Wenn der Sperrstatus entsperrt ist, wird der Aufruf der Methode „acquire()“ den Status in „gesperrt“ ändern und zurückkehren. Wenn der Zustand jedoch gesperrt ist, wird der Aufruf von „acquire()“ blockiert, bis die Methode „release()“ von einem anderen Thread aufgerufen wird.
2. loslassen() Die Methode release() wird verwendet, um den Zustand auf entsperrt zu setzen, d. h. um eine Sperre freizugeben. Es kann von jedem Thread aufgerufen werden, nicht unbedingt von dem, der die Sperre erworben hat.

Hier ist ein Beispiel für die Verwendung von Sperren in Ihren Apps. Starten Sie Ihren IDLE und geben Sie Folgendes ein:

import threading
lock = threading.Lock()

def first_function():
    for i in range(5):
        lock.acquire()
        print ('lock acquired')
        print ('Executing the first funcion')
        lock.release()

def second_function():
    for i in range(5):
        lock.acquire()
        print ('lock acquired')
        print ('Executing the second funcion')
        lock.release()

if __name__=="__main__":
    thread_one = threading.Thread(target=first_function)
    thread_two = threading.Thread(target=second_function)

    thread_one.start()
    thread_two.start()

    thread_one.join()
    thread_two.join()

Drücken Sie jetzt F5. Sie sollten eine Ausgabe wie diese sehen:

CODE-ERKLÄRUNG

1. Hier erstellen Sie einfach eine neue Sperre, indem Sie threading.Lock() aufrufen Fabrikfunktion. Intern gibt Lock() eine Instanz der effektivsten konkreten Lock-Klasse zurück, die von der Plattform verwaltet wird.
2. In der ersten Anweisung erwerben Sie die Sperre, indem Sie die Methode „acquire()“ aufrufen. Wenn die Sperre erteilt wurde, drucken Sie „Sperre erworben“ aus zur Konsole. Sobald der gesamte Code, den der Thread ausführen soll, ausgeführt wurde, geben Sie die Sperre frei, indem Sie die Methode release() aufrufen.

Die Theorie ist gut, aber woher wissen Sie, dass das Schloss wirklich funktioniert hat? Wenn Sie sich die Ausgabe ansehen, sehen Sie, dass jede der Druckanweisungen genau eine Zeile auf einmal druckt. Erinnern Sie sich daran, dass in einem früheren Beispiel die Ausgaben von print willkürlich waren, weil mehrere Threads gleichzeitig auf die Methode print() zugegriffen haben. Hier wird die Druckfunktion erst aufgerufen, nachdem die Sperre erworben wurde. Die Ausgaben werden also einzeln und zeilenweise angezeigt.

Abgesehen von Sperren unterstützt Python auch einige andere Mechanismen zur Handhabung der Thread-Synchronisation, wie unten aufgeführt:

1. RLocks
2. Semaphoren
3. Bedingungen
4. Ereignisse und
5. Barrieren

Globale Interpreter-Sperre (und wie man damit umgeht)

Bevor wir uns mit den Details der GIL von Python befassen, wollen wir einige Begriffe definieren, die für das Verständnis des folgenden Abschnitts nützlich sein werden:

1. CPU-gebundener Code:Dies bezieht sich auf jeden Code, der direkt von der CPU ausgeführt wird.
2. E/A-gebundener Code:Dies kann jeder Code sein, der über das Betriebssystem auf das Dateisystem zugreift
3. CPython:Es ist die Referenzimplementierung von Python und kann als der in C und Python (Programmiersprache) geschriebene Interpreter beschrieben werden.

Was ist GIL in Python?

Globale Dolmetschersperre (GIL) In Python ist eine Prozesssperre oder ein Mutex, der beim Umgang mit den Prozessen verwendet wird. Es stellt sicher, dass jeweils ein Thread auf eine bestimmte Ressource zugreifen kann, und verhindert auch die gleichzeitige Verwendung von Objekten und Bytecodes. Dies kommt den Single-Threaded-Programmen in einer Leistungssteigerung zugute. GIL in Python ist sehr einfach und leicht zu implementieren.

Eine Sperre kann verwendet werden, um sicherzustellen, dass zu einem bestimmten Zeitpunkt nur ein Thread Zugriff auf eine bestimmte Ressource hat.

Eines der Merkmale von Python ist, dass es eine globale Sperre für jeden Interpreter-Prozess verwendet, was bedeutet, dass jeder Prozess den Python-Interpreter selbst als Ressource behandelt.

Angenommen, Sie haben ein Python-Programm geschrieben, das zwei Threads verwendet, um sowohl CPU- als auch E/A-Operationen auszuführen. Wenn Sie dieses Programm ausführen, passiert Folgendes:

1. Der Python-Interpreter erstellt einen neuen Prozess und erzeugt die Threads
2. Wenn Thread-1 zu laufen beginnt, ruft er zuerst die GIL ab und sperrt sie.
3. Wenn Thread-2 jetzt ausgeführt werden möchte, muss er auf die Freigabe der GIL warten, selbst wenn ein anderer Prozessor frei ist.
4. Nehmen Sie nun an, Thread-1 wartet auf eine E/A-Operation. Zu diesem Zeitpunkt wird es die GIL freigeben und Thread-2 wird sie erwerben.
5. Nach Abschluss der E/A-Operationen muss Thread-1, wenn er jetzt ausgeführt werden möchte, erneut warten, bis die GIL von Thread-2 freigegeben wird.

Aus diesem Grund kann immer nur ein Thread auf den Interpreter zugreifen, was bedeutet, dass zu einem bestimmten Zeitpunkt nur ein Thread Python-Code ausführt.

Dies ist in einem Single-Core-Prozessor in Ordnung, da er Time Slicing (siehe erster Abschnitt dieses Tutorials) verwenden würde, um die Threads zu verarbeiten. Im Fall von Mehrkernprozessoren hat jedoch eine CPU-gebundene Funktion, die auf mehreren Threads ausgeführt wird, einen erheblichen Einfluss auf die Effizienz des Programms, da nicht alle verfügbaren Kerne gleichzeitig verwendet werden.

Warum wurde GIL benötigt?

Der CPython-Garbage Collector verwendet eine effiziente Speicherverwaltungstechnik, die als Referenzzählung bekannt ist. So funktioniert es:Jedes Objekt in Python hat einen Referenzzähler, der erhöht wird, wenn es einem neuen Variablennamen zugewiesen oder einem Container hinzugefügt wird (wie Tupel, Listen usw.). Ebenso wird der Verweiszähler verringert, wenn der Verweis den Gültigkeitsbereich verlässt oder wenn die del-Anweisung aufgerufen wird. Wenn der Referenzzähler eines Objekts 0 erreicht, wird es bereinigt und der zugewiesene Speicher wird freigegeben.

Das Problem besteht jedoch darin, dass die Referenzzählvariable wie jede andere globale Variable anfällig für Wettlaufbedingungen ist. Um dieses Problem zu lösen, haben sich die Entwickler von Python entschieden, die globale Interpreter-Sperre zu verwenden. Die andere Option bestand darin, jedem Objekt eine Sperre hinzuzufügen, was zu Deadlocks und erhöhtem Overhead durch die Aufrufe von „accept()“ und „release()“ geführt hätte.

Daher ist GIL eine erhebliche Einschränkung für Multithread-Python-Programme, die schwere CPU-gebundene Operationen ausführen (was sie effektiv zu Single-Thread macht). Wenn Sie mehrere CPU-Kerne in Ihrer Anwendung nutzen möchten, verwenden Sie das Multiprocessing Modul statt.

Zusammenfassung

• Python unterstützt 2 Module für Multithreading:
  1. __Thread Modul:Es bietet eine Low-Level-Implementierung für Threading und ist veraltet.
  2. Threading-Modul :Es bietet eine High-Level-Implementierung für Multithreading und ist der aktuelle Standard.
• Um einen Thread mit dem Threading-Modul zu erstellen, müssen Sie Folgendes tun:
  1. Erstellen Sie eine Klasse, die den Thread erweitert Klasse.
  2. Den Konstruktor überschreiben (__init__).
  3. Den run() überschreiben Methode.
  4. Erzeuge ein Objekt dieser Klasse.
• Ein Thread kann durch Aufrufen von start() ausgeführt werden Methode.
• Der join() Methode kann verwendet werden, um andere Threads zu blockieren, bis dieser Thread (derjenige, auf dem join aufgerufen wurde) die Ausführung beendet.
• Eine Racebedingung tritt auf, wenn mehrere Threads gleichzeitig auf eine gemeinsam genutzte Ressource zugreifen oder diese ändern.
• Es kann vermieden werden, indem Threads synchronisiert werden.
• Python unterstützt 6 Möglichkeiten zum Synchronisieren von Threads:
  1. Schlösser
  2. RLocks
  3. Semaphoren
  4. Bedingungen
  5. Ereignisse und
  6. Barrieren
• Sperren erlauben nur einem bestimmten Thread, der die Sperre erworben hat, in den kritischen Abschnitt einzutreten.
• Eine Sperre hat zwei primäre Methoden:
  1. erwerben() :Es setzt den Sperrzustand auf gesperrt. Wenn es für ein gesperrtes Objekt aufgerufen wird, blockiert es, bis die Ressource frei ist.
  2. loslassen() :Der Sperrstatus wird auf entsperrt gesetzt und kehrt zurück. Wenn es für ein entsperrtes Objekt aufgerufen wird, gibt es false zurück.
• Die globale Interpreter-Sperre ist ein Mechanismus, durch den nur 1 CPython-Interpreter-Prozess gleichzeitig ausgeführt werden kann.
• Es wurde verwendet, um die Referenzzählfunktion des Garbage Collectors von CPythons zu vereinfachen.
• Um Python-Apps mit stark CPU-lastigen Operationen zu erstellen, sollten Sie das Multiprocessing-Modul verwenden.