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。这些是我班级的相关部分：

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