PyEval_InitThreads in Python 3: Wie/Wann Sie es nennen? (die saga geht weiter ad nauseam)

Ihr Verständnis ist korrekt: aufrufen PyEval_InitThreads hat, unter anderem, erwerben die GIL. In einem korrekt geschriebenen Python/C Anwendung ist, ist dies kein Problem, da die GIL wird freigeschaltet in der Zeit, entweder automatisch oder manuell.

Wenn der Haupt-thread geht auf ausführen Python-code, gibt es nichts besonderes zu tun, weil Python-interpreter automatisch verzichten die GIL nach einer Reihe von Anweisungen, die ausgeführt wurden (so dass ein anderer thread, es zu erwerben,, das wird aufgeben es wieder, und so weiter). Zusätzlich, wenn Python ist zu berufen, ein blockierender Systemaufruf, z.B. Lesen von der Netzwerk oder in eine Datei schreiben, wird es lassen Sie die GIL um den Ruf.

Die original-version von dieser Antwort ziemlich viel endete hier. Aber es gibt eine weitere Sache zu berücksichtigen: die Einbettung Szenario.

Wenn das einbetten von Python, der Haupt-thread oft initialisiert Python und geht zum ausführen von anderen, nicht-Python-bezogenen Aufgaben. In diesem Szenario gibt es nichts, was automatisch release der GIL, so muss dies getan werden, indem der thread selbst. Das ist in keiner Weise spezifisch für den Anruf, die Anrufe PyEval_InitThreads es wird erwartet, dass der alle Python/C-code aufgerufen wird, mit der GIL erworben.

Beispielsweise die main() enthält möglicherweise code wie folgt:

Py_Initialize();
PyEval_InitThreads();

Py_BEGIN_ALLOW_THREADS
... call the non-Python part of the application here ...
Py_END_ALLOW_THREADS

Py_Finalize();

Wenn Ihr code erstellt threads manuell, die Sie benötigen, zu erwerben, die GIL vor alles Python-bezogenen, auch so einfach wie Py_INCREF. Verwenden Sie dazu die folgenden:

// Acquire the GIL
PyGILState_STATE gstate;
gstate = PyGILState_Ensure();

... call Python code here ...

// Release the GIL. No Python API allowed beyond this point.
PyGILState_Release(gstate);

Gibt es zwei Methoden der multi-threading, während der Ausführung der C/Python API.

1.Die Ausführung der verschiedenen threads mit den gleichen interpreter - Wir führen einen Python-interpreter und teilen die gleichen Dolmetscher über die verschiedenen threads.

Die Codierung wird wie folgt sein.

main(){     
//initialize Python
Py_Initialize();
PyRun_SimpleString("from time import time,ctime\n"
    "print 'In Main, Today is',ctime(time())\n");

//to Initialize and acquire the global interpreter lock
PyEval_InitThreads();

//release the lock  
PyThreadState *_save;
_save = PyEval_SaveThread();

// Create threads.
for (int i = 0; i<MAX_THREADS; i++)
{   
    hThreadArray[i] = CreateThread
    //(...
        MyThreadFunction,       // thread function name
    //...)

} // End of main thread creation loop.

// Wait until all threads have terminated.
//...
//Close all thread handles and free memory allocations.
//...

//end python here
//but need to check for GIL here too
PyEval_RestoreThread(_save);
Py_Finalize();
return 0;
}

//the thread function

DWORD WINAPI MyThreadFunction(LPVOID lpParam)
{
//non Pythonic activity
//...

//check for the state of Python GIL
PyGILState_STATE gilState;
gilState = PyGILState_Ensure();
//execute Python here
PyRun_SimpleString("from time import time,ctime\n"
    "print 'In Thread Today is',ctime(time())\n");
//release the GIL           
PyGILState_Release(gilState);   

//other non Pythonic activity
//...
return 0;
}

1. Eine andere Methode ist, die wir ausführen können, einen Python-interpreter in den Haupt-thread und zu jedem thread den wir geben können, seine eigene sub-interpreter. So wird jeder thread läuft mit seiner eigenen , unabhängigen Versionen aller importierten Module, einschließlich der grundlegenden Module - gelieferten, __main__ und sys.

Den code wie folgt

int main()
{

// Initialize the main interpreter
Py_Initialize();
// Initialize and acquire the global interpreter lock
PyEval_InitThreads();
// Release the lock     
PyThreadState *_save;
_save = PyEval_SaveThread();


// create threads
for (int i = 0; i<MAX_THREADS; i++)
{

    // Create the thread to begin execution on its own.

    hThreadArray[i] = CreateThread
    //(...

        MyThreadFunction,       // thread function name
    //...);   // returns the thread identifier 

} // End of main thread creation loop.

  // Wait until all threads have terminated.
WaitForMultipleObjects(MAX_THREADS, hThreadArray, TRUE, INFINITE);

// Close all thread handles and free memory allocations.
// ...


//end python here
//but need to check for GIL here too
//re capture the lock
PyEval_RestoreThread(_save);
//end python interpreter
Py_Finalize();
return 0;
}

//the thread functions
DWORD WINAPI MyThreadFunction(LPVOID lpParam)
{
// Non Pythonic activity
// ...

//create a new interpreter
PyEval_AcquireLock(); // acquire lock on the GIL
PyThreadState* pThreadState = Py_NewInterpreter();
assert(pThreadState != NULL); // check for failure
PyEval_ReleaseThread(pThreadState); // release the GIL


// switch in current interpreter
PyEval_AcquireThread(pThreadState);

//execute python code
PyRun_SimpleString("from time import time,ctime\n" "print\n"
    "print 'Today is',ctime(time())\n");

// release current interpreter
PyEval_ReleaseThread(pThreadState);

//now to end the interpreter
PyEval_AcquireThread(pThreadState); // lock the GIL
Py_EndInterpreter(pThreadState);
PyEval_ReleaseLock(); // release the GIL

// Other non Pythonic activity
return 0;
}

Ist es notwendig zu beachten, dass die Globale Interpreter-Sperre noch fortbesteht, und trotz der individuellen Interpreten zu jedem thread, wenn es um python-Ausführung, können wir noch ausführen nur ein thread zu einem Zeitpunkt. GIL ist EINZIGARTIGE zu PROZESS, so dass trotz der Bereitstellung von einzigartigen sub-interpreter zu jedem thread, wir können nicht gleichzeitige Ausführung von threads

Quellen: Ausführen eines Python-interpreter in den Haupt-thread und zu jedem thread den wir geben können, seine eigene sub-interpreter

Multi-threading-tutorial (msdn)

Zitat oben:

Die kurze Antwort: man sollte sich keine Gedanken über die Freigabe der GIL nach dem Aufruf PyEval_InitThreads...

Nun, für eine längere Antwort:

Ich bin beschränken sich meine Antwort werden über Python-Erweiterungen (im Gegensatz zum einbetten von Python). Wenn wir nur die Ausweitung Python, als ein beliebiger Einstiegspunkt in das Modul von Python. Diese per definition bedeutet, dass wir nicht haben, um sorgen über den Aufruf einer Funktion aus einer nicht-Python-Kontext, das macht die Sache ein bisschen einfacher.

Wenn threads NICHT initialisiert werden, dann wissen wir, es gibt keine GIL (keine threads == keine Notwendigkeit für sperren), und damit "Es ist nicht sicher, um diese Funktion aufrufen, wenn es unbekannt ist, welcher thread (wenn überhaupt) derzeit hat die Globale interpreter-Sperre" gilt nicht.

if (!PyEval_ThreadsInitialized())
{
    PyEval_InitThreads();
}

Nach dem Aufruf PyEval_InitThreads(), a GIL erstellt und zugewiesen... zu unserem thread, das ist der thread aktuell ausgeführten Python-code. Also alles ist gut.

Nun, so weit wie unsere eigenen gestarteten worker "C"-threads, die Sie benötigen, zu Fragen, für die GIL vor der Ausführung relevanten code ein: so Ihre gemeinsame Methode ist, wie folgt:

// Do only non-Python things up to this point
PyGILState_STATE state = PyGILState_Ensure();
// Do Python-things here, like PyRun_SimpleString(...)
PyGILState_Release(state);
// ... and now back to doing only non-Python things

Wir nicht haben, um sorgen über Deadlocks mehr, als von einer normalen Nutzung von Erweiterungen. Wenn wir in unsere Funktion, wir hatten die Kontrolle über Python, also entweder wir waren nicht unter Verwendung von Fäden (also kein GIL), oder die GIL war bereits jetzt an uns abgetreten. Wenn wir die Kontrolle zurück in die Python-Laufzeit durch verlassen unserer Funktion, der normalen Verarbeitung-Schleife prüft die GIL und Kontrolle über die als angemessen, andere anfordernde Objekte: darunter unser worker-threads über PyGILState_Ensure().

All dies dem Leser wahrscheinlich schon weiß. Aber der "Beweis ist in den pudding". Ich habe eine sehr-minimal-Beispiel dokumentiert, dass ich schrieb, die heute zu lernen für mich, was das Verhalten eigentlich war, und dass alles richtig funktioniert. Beispiel-Source-Code auf GitHub

Lernte ich einige Dinge mit dem Beispiel CMake-integration mit Python-Entwicklungs -, SCHLUCK-integration mit den beiden oben genannten, und Python Verhaltensweisen, die mit Erweiterungen und threads. Dennoch, der Kern der Beispiel können Sie:

• Laden Sie das Modul -- 'import ärgern'
• Last null oder mehr worker-threads, die Python Sachen -- 'ärgern.Nerven(n)'
• Klar, dass alle worker-threads -- 'annon.ärgern(0)'
• Bieten thread-Bereinigung (auf Linux) auf das beenden der Anwendung

... und das alles ohne Abstürze oder Zugriffsfehler. Zumindest auf meinem system (Ubuntu Linux w/GCC).

Ich das Gefühl zu verwirren, auf dieses Problem zu. Der folgende code funktioniert, durch Zufall.

Py_InitializeEx(0);
    if (!PyEval_ThreadsInitialized()) {
    PyEval_InitThreads();
    PyThreadState* mainPyThread = PyEval_SaveThread();
}

Mein Haupt-thread einige python-Laufzeitumgebung ersten arbeiten, und erstellen Sie andere pthread zu erledigen. Und ich habe eine bessere Lösung für dieses. In der Main-thread:

if (!PyEval_ThreadsInitialized()){
    PyEval_InitThreads();
}
//other codes
while(alive) {
    Py_BEGIN_ALLOW_THREADS
    sleep or other block code
    Py_END_ALLOW_THREADS
}