Multithreading in Python met voorbeeld:leer GIL in Python

Op elk moment moet een filosoof eten of denken.

Bovendien moet een filosoof de twee vorken naast hem nemen (d.w.z. de linker- en rechtervork) voordat hij de spaghetti kan eten. Het probleem van een impasse doet zich voor wanneer alle vijf filosofen tegelijkertijd hun rechtervork oppakken.

Aangezien elk van de filosofen één vork heeft, zullen ze allemaal wachten tot de anderen hun vork neerleggen. Als gevolg hiervan zal geen van hen spaghetti kunnen eten.

Evenzo treedt in een gelijktijdig systeem een ​​impasse op wanneer verschillende threads of processen (filosofen) tegelijkertijd proberen de gedeelde systeembronnen (forks) te verwerven. Als gevolg hiervan krijgt geen van de processen de kans om uit te voeren omdat ze wachten op een andere bron die door een ander proces wordt vastgehouden.

Racevoorwaarden

Een raceconditie is een ongewenste toestand van een programma die optreedt wanneer een systeem twee of meer bewerkingen tegelijk uitvoert. Beschouw bijvoorbeeld deze eenvoudige for-lus:

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

Als u n . maakt aantal threads dat deze code tegelijk uitvoert, kunt u de waarde van i (die wordt gedeeld door de threads) niet bepalen wanneer het programma klaar is met uitvoeren. Dit komt omdat in een echte multithreading-omgeving de threads elkaar kunnen overlappen, en de waarde van i die is opgehaald en gewijzigd door een thread kan tussentijds veranderen wanneer een andere thread er toegang toe heeft.

Dit zijn de twee belangrijkste soorten problemen die kunnen optreden in een multithreaded of gedistribueerde python-toepassing. In het volgende gedeelte leert u hoe u dit probleem kunt oplossen door threads te synchroniseren.

Draden synchroniseren

Om race-omstandigheden, deadlocks en andere op threads gebaseerde problemen aan te pakken, biedt de threading-module de Lock object. Het idee is dat wanneer een thread toegang wil tot een specifieke bron, deze een slot voor die bron krijgt. Zodra een thread een bepaalde bron vergrendelt, heeft geen enkele andere thread er toegang toe totdat de vergrendeling wordt vrijgegeven. Als gevolg hiervan zullen de wijzigingen aan de bron atomair zijn en worden race-omstandigheden afgewend.

Een vergrendeling is een primitief voor synchronisatie op laag niveau, geïmplementeerd door de __thread module. Een slot kan zich op elk moment in een van de 2 toestanden bevinden:vergrendeld of ontgrendeld. Het ondersteunt twee methoden:

1. verkrijgen() Wanneer de lock-status is ontgrendeld, zal het aanroepen van de methode acquire() de status wijzigen in vergrendeld en terugkeren. Als de status echter is vergrendeld, wordt de aanroep van acquire() geblokkeerd totdat de methode release() wordt aangeroepen door een andere thread.
2. release() De methode release() wordt gebruikt om de status in te stellen op ontgrendeld, d.w.z. om een ​​vergrendeling op te heffen. Het kan door elke thread worden aangeroepen, niet noodzakelijk degene die het slot heeft verkregen.

Hier is een voorbeeld van het gebruik van vergrendelingen in uw apps. Start uw IDLE op en typ het volgende:

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()

Druk nu op F5. Je zou een uitvoer als deze moeten zien:

CODE UITLEG

1. Hier maakt u eenvoudig een nieuwe vergrendeling door de threading.Lock() aan te roepen fabrieksfunctie. Intern retourneert Lock() een instantie van de meest effectieve concrete Lock-klasse die door het platform wordt onderhouden.
2. In de eerste instructie verkrijgt u de vergrendeling door de methode acquire() aan te roepen. Wanneer het slot is verleend, drukt u "slot verworven" . af naar de console. Zodra alle code die u de thread wilt laten uitvoeren, is uitgevoerd, geeft u de vergrendeling op door de methode release() aan te roepen.

De theorie is prima, maar hoe weet je dat het slot echt werkte? Als u naar de uitvoer kijkt, ziet u dat elk van de afdrukinstructies precies één regel tegelijk afdrukt. Bedenk dat in een eerder voorbeeld de uitvoer van print lukraak was omdat meerdere threads tegelijkertijd toegang hadden tot de methode print(). Hier wordt de afdrukfunctie pas aangeroepen nadat de vergrendeling is verkregen. De uitgangen worden dus één voor één en regel voor regel weergegeven.

Afgezien van vergrendelingen, ondersteunt python ook enkele andere mechanismen om threadsynchronisatie af te handelen, zoals hieronder vermeld:

1. Rvergrendelingen
2. Semaforen
3. Voorwaarden
4. Evenementen, en
5. Barrières

Global Interpreter Lock (en hoe ermee om te gaan)

Voordat we ingaan op de details van python's GIL, laten we eerst een paar termen definiëren die nuttig zullen zijn bij het begrijpen van de komende sectie:

1. CPU-gebonden code:dit verwijst naar elk stukje code dat direct door de CPU wordt uitgevoerd.
2. I/O-gebonden code:dit kan elke code zijn die toegang heeft tot het bestandssysteem via het besturingssysteem
3. CPython:het is de referentie implementatie van Python en kan worden omschreven als de tolk geschreven in C en Python (programmeertaal).

Wat is GIL in Python?

Global Interpreter Lock (GIL) in python is een procesvergrendeling of een mutex die wordt gebruikt bij het afhandelen van de processen. Het zorgt ervoor dat één thread tegelijkertijd toegang heeft tot een bepaalde bron en het voorkomt ook dat objecten en bytecodes tegelijk worden gebruikt. Dit komt de single-threaded programma's ten goede in een prestatieverhoging. GIL in python is heel eenvoudig en gemakkelijk te implementeren.

Een slot kan worden gebruikt om ervoor te zorgen dat slechts één thread tegelijkertijd toegang heeft tot een bepaalde bron.

Een van de kenmerken van Python is dat het een globaal slot op elk interpreterproces gebruikt, wat betekent dat elk proces de Python-interpreter zelf als een hulpbron behandelt.

Stel dat u bijvoorbeeld een python-programma hebt geschreven dat twee threads gebruikt om zowel CPU- als 'I/O'-bewerkingen uit te voeren. Als je dit programma uitvoert, gebeurt dit:

1. De python-interpreter creëert een nieuw proces en spawnt de threads
2. Als thread-1 begint te lopen, zal het eerst de GIL ophalen en vergrendelen.
3. Als thread-2 nu wil worden uitgevoerd, moet het wachten tot de GIL wordt vrijgegeven, zelfs als een andere processor vrij is.
4. Veronderstel nu dat thread-1 wacht op een I/O-bewerking. Op dit moment zal het de GIL vrijgeven, en thread-2 zal het verwerven.
5. Na het voltooien van de I/O-operaties, als thread-1 nu wil worden uitgevoerd, zal het opnieuw moeten wachten tot de GIL wordt vrijgegeven door thread-2.

Hierdoor heeft slechts één thread tegelijkertijd toegang tot de interpreter, wat betekent dat er slechts één thread op een bepaald moment python-code uitvoert.

Dit is in orde in een single-coreprocessor omdat het time-slicing zou gebruiken (zie het eerste deel van deze tutorial) om de threads af te handelen. In het geval van multi-coreprocessors zal een CPU-gebonden functie die wordt uitgevoerd op meerdere threads echter een aanzienlijke impact hebben op de efficiëntie van het programma, aangezien het niet alle beschikbare cores tegelijkertijd zal gebruiken.

Waarom was GIL nodig?

De CPython-afvalverzamelaar gebruikt een efficiënte geheugenbeheertechniek die bekend staat als referentietelling. Zo werkt het:elk object in python heeft een referentietelling, die wordt verhoogd wanneer het wordt toegewezen aan een nieuwe variabelenaam of wordt toegevoegd aan een container (zoals tupels, lijsten, enz.). Evenzo wordt het aantal referenties verlaagd wanneer de referentie buiten het bereik valt of wanneer de del-instructie wordt aangeroepen. Wanneer de referentietelling van een object 0 bereikt, wordt het afval verzameld en wordt het toegewezen geheugen vrijgemaakt.

Maar het probleem is dat de referentietellingsvariabele net als elke andere globale variabele gevoelig is voor race-omstandigheden. Om dit probleem op te lossen, hebben de ontwikkelaars van python besloten om de global interpreter lock te gebruiken. De andere optie was om een ​​vergrendeling toe te voegen aan elk object, wat zou hebben geleid tot impasses en meer overhead van de aanroepen van acquire() en release().

Daarom is GIL een belangrijke beperking voor python-programma's met meerdere threads die zware CPU-gebonden bewerkingen uitvoeren (waardoor ze effectief single-threaded worden). Als je gebruik wilt maken van meerdere CPU-cores in je applicatie, gebruik dan de multiprocessing module in plaats daarvan.

Samenvatting

• Python ondersteunt 2 modules voor multithreading:
  1. __thread module:het biedt een implementatie op laag niveau voor threading en is verouderd.
  2. threading-module :Het biedt een implementatie op hoog niveau voor multithreading en is de huidige standaard.
• Als u een thread wilt maken met behulp van de threading-module, moet u het volgende doen:
  1. Maak een klasse die de Thread uitbreidt klas.
  2. Overschrijf zijn constructor (__init__).
  3. Overschrijf zijn run() methode.
  4. Maak een object van deze klasse.
• Een thread kan worden uitgevoerd door de start() . aan te roepen methode.
• De join() methode kan worden gebruikt om andere threads te blokkeren totdat deze thread (degene waarop de join werd aangeroepen) de uitvoering voltooit.
• Er treedt een raceconditie op wanneer meerdere threads tegelijkertijd toegang krijgen tot een gedeelde bron of deze wijzigen.
• Het kan worden vermeden door threads te synchroniseren.
• Python ondersteunt 6 manieren om threads te synchroniseren:
  1. Sloten
  2. Rvergrendelingen
  3. Semaforen
  4. Voorwaarden
  5. Evenementen, en
  6. Barrières
• Locks laten alleen een bepaalde thread toe die de lock heeft gekregen om de kritieke sectie te betreden.
• Een slot heeft 2 primaire methoden:
  1. verkrijgen() :Het stelt de vergrendelingsstatus in op vergrendeld. Als een vergrendeld object wordt aangeroepen, wordt het geblokkeerd totdat de bron vrij is.
  2. release() :Het stelt de vergrendelingsstatus in op ontgrendeld en keert terug. Als een ontgrendeld object wordt aangeroepen, retourneert het false.
• De globale interpretervergrendeling is een mechanisme waardoor slechts 1 CPython-interpreterproces tegelijk kan worden uitgevoerd.
• Het werd gebruikt om de functie voor het tellen van referenties van de afvalverzamelaar van CPythons te vergemakkelijken.
• Om Python-apps te maken met zware CPU-gebonden bewerkingen, moet je de multiprocessing-module gebruiken.