Python Language
Werken rond de Global Interpreter Lock (GIL)

Opmerkingen

Multiprocessing.Pool

Het eenvoudige antwoord bij het vragen hoe threads in Python te gebruiken is: "Niet doen. Gebruik in plaats daarvan processen." Met de multiprocessing-module kunt u processen maken met dezelfde syntaxis als het maken van threads, maar ik gebruik liever hun handige Pool-object.

Met behulp van de code die David Beazley voor het eerst gebruikte om de gevaren van threads tegen de GIL te tonen , zullen we het herschrijven met behulp van multiprocessing .

David Beazley's code die GIL threading problemen liet zien

from threading import Thread
import time
def countdown(n):
    while n > 0:
        n -= 1

COUNT = 10000000

t1 = Thread(target=countdown,args=(COUNT/2,))
t2 = Thread(target=countdown,args=(COUNT/2,))
start = time.time()
t1.start();t2.start()
t1.join();t2.join()
end = time.time()
print end-start

import multiprocessing
import time
def countdown(n):
    while n > 0:
        n -= 1

COUNT = 10000000

start = time.time()
with multiprocessing.Pool as pool:
    pool.map(countdown, [COUNT/2, COUNT/2])

    pool.close()
    pool.join()

end = time.time()
print(end-start)

In plaats van threads te maken, creëert dit nieuwe processen. Omdat elk proces zijn eigen tolk is, zijn er geen GIL-botsingen. multiprocessing.Pool opent zoveel processen als er cores op de machine zijn, hoewel in het bovenstaande voorbeeld er slechts twee nodig zijn. In een realistisch scenario wilt u uw lijst zo ontwerpen dat deze minstens even lang is als er processors op uw machine staan. De pool voert de functie uit die u hem bij elk argument wilt laten uitvoeren, tot het aantal processen dat wordt gecreëerd. Wanneer de functie is voltooid, worden alle resterende functies in de lijst op dat proces uitgevoerd.

Ik heb ontdekt dat, zelfs met de instructie with , de processen blijven bestaan als je niet sluit en je bij de pool aansluit. Om bronnen op te schonen, sluit en sluit ik altijd aan bij mijn pools.

Cython nogil:

Cython is een alternatieve python-tolk. Het gebruikt de GIL, maar laat je het uitschakelen. Zie hun documentatie

Als voorbeeld gebruiken we de code die David Beazley voor het eerst gebruikte om de gevaren van threads tegen de GIL aan te tonen , en herschrijven we deze met nogil:

David Beazley's code die GIL threading problemen liet zien

from threading import Thread
import time
def countdown(n):
    while n > 0:
        n -= 1

COUNT = 10000000

t1 = Thread(target=countdown,args=(COUNT/2,))
t2 = Thread(target=countdown,args=(COUNT/2,))
start = time.time()
t1.start();t2.start()
t1.join();t2.join()
end = time.time()
print end-start

Herschreven met nogil (ALLEEN WERKT IN CYTHON):

from threading import Thread
import time
def countdown(n):
    while n > 0:
        n -= 1

COUNT = 10000000

with nogil:
    t1 = Thread(target=countdown,args=(COUNT/2,))
    t2 = Thread(target=countdown,args=(COUNT/2,))
    start = time.time()
    t1.start();t2.start()
    t1.join();t2.join()
    
end = time.time()
print end-start

Zo eenvoudig is het zolang je cython gebruikt. Merk op dat de documentatie zegt dat je ervoor moet zorgen dat je geen python-objecten wijzigt:

Code in de hoofdtekst van de instructie mag op geen enkele manier Python-objecten manipuleren en mag niets aanroepen dat Python-objecten manipuleert zonder eerst de GIL opnieuw te verwerven. Cython controleert dit momenteel niet.