Che cos'è un blocco dell'interprete globale (GIL)?

Question

Che cos'è un blocco dell'interprete globale e perché è un problema?

Un sacco di rumore è stato fatto intorno rimuovere il GIL da Python, e mi piacerebbe capire il motivo per cui è così importante. Non ho mai scritto un compilatore né un interprete, quindi non essere frugale con i dettagli, probabilmente avrò bisogno che loro capiscano.

Answer 1

GIL di Python è destinato a serializzare l'accesso alle parti interne interprete di diversi thread. Sui sistemi multi-core, significa che più thread non possono effettivamente fare uso di più core. (Se il GIL non ha portato a questo problema, la maggior parte delle persone non si preoccuperebbe del GIL - è solo sollevato come un problema a causa della crescente prevalenza di sistemi multi-core.) Se vuoi capirlo in dettaglio, è possibile visualizzare this video oppure guardare this set of slides. Potrebbe essere troppe informazioni, ma poi hai chiesto i dettagli :-)

Si noti che GIL di Python è solo un problema per CPython, l'implementazione di riferimento. Jython e IronPython non hanno un GIL. Come sviluppatore Python, in genere non si incontra GIL a meno che non si stia scrivendo un'estensione C. Gli autori di estensioni C devono rilasciare GIL quando le loro estensioni bloccano l'I/O, in modo che altri thread nel processo Python abbiano la possibilità di essere eseguiti.

Aggiornamento: Link aggiornato al video per puntare su Youtube, poiché il precedente collegamento blip.tv era marcito.

Answer 2

Supponiamo di avere più thread che non in realtà si toccano reciprocamente i dati. Questi dovrebbero essere eseguiti nel modo più indipendente possibile. Se si dispone di un "blocco globale" che è necessario acquisire per chiamare una funzione, può essere considerato un collo di bottiglia. È possibile non trarre molto vantaggio dall'avere più thread in primo luogo.

di metterla in una vera analogia mondo: immaginate 100 sviluppatori che lavorano in una società con una sola tazza di caffè. La maggior parte degli sviluppatori passerebbe il loro tempo ad aspettare caffè invece di programmare.

Niente di tutto questo è Python-specifica - Non conosco i dettagli di ciò che aveva bisogno di un Python GIL per in primo luogo. Tuttavia, si spera che ti abbia dato un'idea migliore del concetto generale.

Answer 3

Wikipedia ha una bella descrizione di un interprete globale bloccare

http://en.wikipedia.org/wiki/Global_Interpreter_Lock

che collega articolo questo bell'articolo che discute la GIL in Python.

http://www.ddj.com/linux-open-source/206103078?pgno=2

Answer 4

Ogni volta che due thread hanno accesso alla stessa variabile avete un problema. In C++, ad esempio, il modo per evitare il problema è definire un blocco mutex per impedire che due thread, diciamo, inseriscano il setter di un oggetto nello stesso momento.

Il multithreading è possibile in python, ma due thread non possono essere eseguiti contemporaneamente a con una granularità più fine rispetto a un'istruzione python. Il thread in esecuzione sta ricevendo un blocco globale chiamato GIL.

Questo significa che se si inizia scrivere del codice multithreading al fine di sfruttare il processore multicore, le prestazioni non migliorerà. La soluzione usuale consiste nell'adozione di processi multipli.

Si noti che è possibile rilasciare GIL se si è all'interno di un metodo che è stato scritto in C, ad esempio.

L'uso di un GIL non è inerente a Python ma ad alcuni dei suoi interpreti, incluso il CPython più comune. (#edited, vedi commento)

La questione GIL è ancora valido in Python 3000.

Answer 5

Watch David Beazley dirvi tutto quello che avreste sempre voluto sapere sul GIL.

Answer 6

Ecco un articolo molto lungo che parla del GIL e del threading in Python che ho scritto qualche tempo fa. Si entra in una discreta quantità di dettagli su di esso:

http://jessenoller.com/2009/02/01/python-threads-and-the-global-interpreter-lock/

Answer 7

Facciamo capire prima quello che il pitone GIL prevede:

Qualsiasi operazione/istruzione viene eseguita in l'interprete. GIL garantisce che l'interprete sia tenuto da un singolo thread al in un particolare istante di tempo. E il tuo programma python con più thread funziona in un singolo interprete. In ogni particolare istante di tempo, questo interprete è tenuto da un singolo thread. Significa che solo il thread che regge l'interprete è in esecuzione allo in qualsiasi istante di tempo.

Ora, perché è che un problema:

La macchina potrebbe essere avere più core/processori. Inoltre, più core consentono l'esecuzione simultanea di più thread in modo che più thread possano eseguire in qualsiasi momento specifico.. Ma poiché l'interprete è contenuto da un singolo thread, altri thread non stanno facendo nulla anche se hanno accesso a un core. Quindi, non si ottiene alcun vantaggio fornito da più core, perché in qualsiasi istante viene utilizzato solo un singolo core, che è il nucleo utilizzato dal thread attualmente in possesso dell'interprete. Quindi, il tuo programma impiegherà il tempo necessario per eseguirlo come se fosse un programma a thread singolo.

Tuttavia, le operazioni potenzialmente bloccanti o di lunga durata, come I/O, elaborazione immagine e numerazione dei numeri NumPy, si verificano all'esterno di GIL. Tratto da here. Pertanto, per tali operazioni, un'operazione con multithreading sarà ancora più veloce di un'operazione a thread singolo nonostante la presenza di GIL. Quindi, GIL non è sempre un collo di bottiglia.

Modifica: GIL è un dettaglio di implementazione di CPython. PyPy e Jython non hanno GIL, quindi un programma veramente multithread dovrebbe essere possibile in loro, pensavo che non ho mai usato PyPy e Jython e non ne sono sicuro.

Answer 8

Ecco alcuni codice che illustrano gli effetti della GIL: https://github.com/cankav/python_gil_demonstration

Answer 9

Perché Python (CPython e altri) utilizza la GIL

Da http://wiki.python.org/moin/GlobalInterpreterLock

Nel CPython, il blocco interprete globale, o GIL , è un mutex che impedisce a più thread nativi di eseguire bytecode Python contemporaneamente. Questo blocco è necessario principalmente perché la gestione della memoria di CPython non è thread-safe.

Come rimuoverlo da Python?

Come Lua, forse Python potrebbe avviare più VM, ma Python non lo fa, credo che ci dovrebbero essere altri motivi.

In Numpy o in qualche altra libreria estesa di Python, a volte, il rilascio di GIL su altri thread potrebbe aumentare l'efficienza dell'intero programma.

Answer 10

Voglio condividere un esempio dal multithreading del libro per effetti visivi. Quindi ecco una classica situazione di blocco morto

static void MyCallback(const Context &context){ 
Auto<Lock> lock(GetMyMutexFromContext(context)); 
... 
EvalMyPythonString(str); //A function that takes the GIL 
...  
} 

Considerare ora gli eventi nella sequenza risultante in un dead-lock.

╔═══╦════════════════════════════════════════╦══════════════════════════════════════╗ 
║ ║ Main Thread       ║ Other Thread       ║ 
╠═══╬════════════════════════════════════════╬══════════════════════════════════════╣ 
║ 1 ║ Python Command acquires GIL   ║ Work started       ║ 
║ 2 ║ Computation requested     ║ MyCallback runs and acquires MyMutex ║ 
║ 3 ║          ║ MyCallback now waits for GIL   ║ 
║ 4 ║ MyCallback runs and waits for MyMutex ║ waiting for GIL      ║ 
╚═══╩════════════════════════════════════════╩══════════════════════════════════════╝ 

Answer 11

Trovo che questa sia la spiegazione migliore di GIL. Si prega di leggere.

http://www.dabeaz.com/python/UnderstandingGIL.pdf

Answer 12

Python non permette il multi-threading nel vero senso della parola. Ha un pacchetto multi-threading ma se vuoi multi-thread per velocizzare il tuo codice, di solito non è una buona idea usarlo. Python ha un costrutto chiamato Global Interpreter Lock (GIL). GIL si assicura che solo uno dei tuoi "thread" possa essere eseguito in qualsiasi momento. Un thread acquisisce il GIL, fa un po 'di lavoro, quindi passa GIL sul thread successivo. Questo accade molto velocemente, quindi all'occhio umano potrebbe sembrare che i tuoi thread siano eseguiti in parallelo, ma in realtà stanno solo prendendo a turno usando lo stesso core della CPU. Tutto questo passaggio di GIL aggiunge un sovraccarico all'esecuzione. Ciò significa che se vuoi far funzionare il tuo codice più velocemente, usare spesso il pacchetto di threading non è una buona idea.

Ci sono motivi per utilizzare il pacchetto di threading di Python. Se vuoi eseguire alcune cose contemporaneamente, e l'efficienza non è una preoccupazione, allora è assolutamente soddisfacente. Oppure se stai usando un codice che deve aspettare qualcosa (come un qualche IO), allora potrebbe avere molto senso. Ma la libreria di threading non ti consente di utilizzare core CPU aggiuntivi.

Il multi-threading può essere esternalizzato al sistema operativo (tramite multielaborazione), alcune applicazioni esterne che chiamano il codice Python (ad esempio, Spark o Hadoop) o un codice che il codice Python chiama (ad es. potrebbe avere il tuo codice Python chiamare una funzione C che fa le costose cose multi-thread).