C++通过Python C API调用Python脚本后获取生成数据的问题

嘿，我看你遇到了C++多线程调用Python API的坑——这十有八九是**Python GIL（全局解释器锁）**在搞鬼！结合你的场景，我帮你梳理下问题根源和具体的解决办法，亲测有效～

问题根源 #

Python解释器的GIL规定：同一时间只有一个线程能执行Python字节码或调用Python API。你在C++新线程里直接调用getData函数，没有正确获取GIL和初始化线程状态，必然会导致解释器状态混乱，出现崩溃、数据错误或者莫名其妙的异常。

另外，你在main线程生成的随机数，如果直接存在全局变量里，多线程访问也会有数据竞争的问题，得加锁保护。

具体解决步骤 #

1. 给C++线程套上Python上下文的“安全壳” #

每个要调用Python API的C++线程，必须先获取GIL，用完再释放。我们可以封装成两个辅助函数，方便复用：

#include <Python.h>

// 进入Python线程上下文：获取GIL，初始化线程状态
void enter_python_context() {
    // 保存GIL状态到线程局部存储，避免线程间干扰
    thread_local PyGILState_STATE gstate = PyGILState_Ensure();
}

// 退出Python线程上下文：释放GIL，清理线程状态
void exit_python_context() {
    thread_local PyGILState_STATE gstate;
    PyGILState_Release(gstate);
}

2. 给Python脚本的随机数加线程安全锁 #

修改loop.py，用threading.Lock保护存储随机数的全局变量，避免多线程读写冲突：

import random
import threading
import time

# 全局存储随机数，加锁保护
_random_data = None
_data_lock = threading.Lock()

def main():
    global _random_data
    while True:
        # 生成随机数
        new_num = random.randint(1, 100)
        # 加锁写入
        with _data_lock:
            _random_data = new_num
        # 加个休眠，避免过度占用资源
        time.sleep(0.1)

def getData():
    global _random_data
    # 加锁读取
    with _data_lock:
        return _random_data if _random_data is not None else 0

3. 调整C++多线程调用逻辑 #

确保Python解释器只在主线程初始化和销毁，子线程调用Python函数时必须先进入上下文：

#include <thread>
#include <iostream>
#include <chrono>

class PythonWrapper {
public:
    // 仅在主线程调用：初始化Python解释器，导入模块和函数
    static void init() {
        if (!Py_IsInitialized()) {
            Py_Initialize();
        }

        // 导入loop.py模块
        pModule = PyImport_ImportModule("loop");
        if (!pModule) {
            PyErr_Print();
            exit(EXIT_FAILURE);
        }

        // 获取main和getData函数
        pMainFunc = PyObject_GetAttrString(pModule, "main");
        pGetDataFunc = PyObject_GetAttrString(pModule, "getData");
        
        // 检查函数是否可调用
        if (!pMainFunc || !pGetDataFunc || !PyCallable_Check(pMainFunc) || !PyCallable_Check(pGetDataFunc)) {
            PyErr_Print();
            exit(EXIT_FAILURE);
        }
    }

    // 子线程运行main函数的逻辑
    static void run_main_loop() {
        enter_python_context();
        // 调用main函数（死循环会一直运行，根据需求调整）
        PyObject_CallObject(pMainFunc, nullptr);
        exit_python_context();
    }

    // 读取随机数的接口
    static int get_random_number() {
        enter_python_context();
        int result = 0;
        PyObject* pResult = PyObject_CallObject(pGetDataFunc, nullptr);
        
        if (pResult) {
            result = PyLong_AsLong(pResult);
            Py_DECREF(pResult); // 释放Python对象，避免内存泄漏
        } else {
            PyErr_Print(); // 打印错误信息，方便调试
        }
        
        exit_python_context();
        return result;
    }

    // 仅在主线程调用：清理Python资源
    static void cleanup() {
        Py_DECREF(pMainFunc);
        Py_DECREF(pGetDataFunc);
        Py_DECREF(pModule);
        if (Py_IsInitialized()) {
            Py_Finalize();
        }
    }

private:
    static PyObject* pModule;
    static PyObject* pMainFunc;
    static PyObject* pGetDataFunc;
};

// 初始化静态成员变量
PyObject* PythonWrapper::pModule = nullptr;
PyObject* PythonWrapper::pMainFunc = nullptr;
PyObject* PythonWrapper::pGetDataFunc = nullptr;

int main() {
    // 主线程初始化Python
    PythonWrapper::init();

    // 启动子线程运行Python的main函数
    std::thread main_thread(&PythonWrapper::run_main_loop);
    main_thread.detach(); // 根据需求选择detach或join

    // 在主线程（或另一个子线程）测试获取随机数
    for (int i = 0; i < 10; ++i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
        int num = PythonWrapper::get_random_number();
        std::cout << "获取到随机数：" << num << std::endl;
    }

    // 主线程清理资源
    PythonWrapper::cleanup();
    return 0;
}

几个关键提醒 #

• Py_Initialize()和Py_Finalize()必须只在主线程调用，子线程不能初始化或销毁解释器。
• 所有调用Python API的代码，必须包裹在enter_python_context()和exit_python_context()之间，GIL的获取和释放必须成对。
• Python对象的引用计数要管好：用Py_DECREF()释放不再需要的PyObject，避免内存泄漏。
• 如果还是出现问题，把PyErr_Print()输出的错误信息贴出来，能更快定位问题～

内容的提问来源于stack exchange，提问作者SarahT