c++ - Python GIL 和线程

Question

我在我的大型 C++ 应用程序中嵌入了 Python3。 Python 赋予了用户自定义数据处理脚本的能力。
问题:我有许多与 Python 交互的线程，但我并不真正了解如何使用 GIL 保护我的代码。到目前为止，我使代码正常工作的唯一方法是使用 boost::mutex。

这是一个重现我的问题的非常简单的例子:

• 线程A首先调用Init()来初始化Python(静态函数)。
• 线程 B 调用 Pythonize() 在 Python 上做一些工作。线程 B 在第一次调用锁定 GIL 时被阻塞。

代码:

#include <iostream>
#include <boost/thread.hpp>
#include <boost/bind.hpp>

#include "Python.h"

struct RTMaps_GILLock
{
    RTMaps_GILLock()
    {
        std::cout << "Locking..." << std::endl;
        m_state = PyGILState_Ensure();
    }

    ~RTMaps_GILLock()
    {
        std::cout << "Unlocking..." << std::endl;
        PyGILState_Release(m_state);
    }

private:
    PyGILState_STATE m_state;
};
#define GILLOCK RTMaps_GILLock lock;

class PythonEmbed
{
public:
    static void Init()
    {
        Py_Initialize();
        // EDIT : adding those two lines made my day :
        PyEval_InitThreads(); // This acquires GIL
        PyEval_SaveThread(); // Release the GIL
    }

    void Pythonize()
    {
        GILLOCK;
        // Never goes here :(
        std::cout << "OK" << std::endl;
    }
};

int main()
{
    PythonEmbed::Init();

    PythonEmbed pyt;
    boost::thread t(boost::bind(&PythonEmbed::Pythonize, pyt));

    t.join();
}

第一次锁调用就死锁了。控制台显示: 锁定...

永远不会打印“OK”。我做错了什么？

编辑:更正代码，现在可以正常工作了。我需要从主线程释放 GIL。

Answer 1

我遇到了你的确切问题，请确保不要从主线程(初始化 Python 的线程)调用 PyGILState_Ensure()，因为它需要完全不同的调用。我已经结束设置线程映射器，并且每次调用我的 acquirePython() 都会检查哪个线程正在调用它，如果它是主线程，它会使用:

PyEval_SaveThread();

否则它存储 GIL。这些是我类(class)的相关部分:

void MManager::acquirePython(void) {
    MThread thisThread = MFramework::MProcesses::GetCurrentThread();
    if (thisThread != mainThread) {
        Lock();
        std::map<MThread,void*>::iterator i = threadStates.find(thisThread);
        if (i == threadStates.end()) {
            Unlock();
            PyGILState_STATE gstate = PyGILState_Ensure();
            _PyGILState_STATE_* encState = new _PyGILState_STATE_;
            encState->state = gstate;
            encState->refCount = 1;
            Lock();
            threadStates[thisThread] = encState;
            Unlock();
        } else {
            _PyGILState_STATE_* encState = (_PyGILState_STATE_*)i->second;
            encState->refCount = encState->refCount + 1;
            Unlock();
        }

    } else {
        if (mainThreadState) PyEval_RestoreThread((PyThreadState*)mainThreadState);
    }

}

void MManager::releasePython(void) {
    MThread thisThread = MFramework::MProcesses::GetCurrentThread();
    if (thisThread != mainThread) {
        Lock();
        std::map<MThread,void*>::iterator i = threadStates.find(thisThread);
        if (i != threadStates.end()) {
            _PyGILState_STATE_* encState = (_PyGILState_STATE_*)i->second;
            if (encState->refCount <= 1) {
                threadStates.erase(i);
                Unlock();

                PyGILState_Release(encState->state);
                delete encState;
            } else {
                encState->refCount = encState->refCount - 1;
                Unlock();
            }
        } else {
            Unlock();
        }

    } else {
        mainThreadState = PyEval_SaveThread();
    }
}