Python子解释器多线程GIL释放异常求助

首先，你遇到的两个致命错误本质都是Python线程状态（tstate）与GIL管理的逻辑漏洞，咱们一步步拆解问题所在，再给出修正后的代码：

错误原因解读 #

1. Fatal Python error: drop_gil: GIL is not locked：
   调用PyEval_SaveThread()时，当前线程并没有持有GIL。这个函数的作用是释放GIL并保存当前线程状态，前提是当前线程必须已经持有GIL，否则就会触发这个致命错误。

2. Fatal Python error: PyEval_SaveThread: NULL tstate：
   当前线程没有有效的Python线程状态（tstate）。通常是因为线程状态切换失败，导致PyThreadState_Get()返回NULL，进而触发这个错误。

代码中的核心问题 #

1. 主线程创建子解释器时的状态混乱 #

Py_NewInterpreter()会自动将新创建的子解释器对应的线程状态设置为当前线程的活跃tstate。如果你不及时换回主线程的原始tstate，后续创建第二个子解释器、甚至其他Python操作都会在第一个子解释器的上下文中执行，导致状态冲突。

2. 子线程未正确获取GIL就尝试释放 #

在非Python线程中，你创建了子解释器对应的tstate并切换到该状态，但此时线程并没有持有GIL——GIL是全局锁，新线程默认不会持有它。直接调用PyEval_SaveThread()尝试释放一个未持有的GIL，必然触发错误。

修正后的完整代码 #

#include <iostream>
#include <thread>
#include <Python.h>

void worker(PyInterpreterState* interp, int n) {
    // 1. 为当前线程创建绑定到目标子解释器的线程状态
    PyThreadState* ts = PyThreadState_New(interp);
    if (!ts) {
        std::cerr << "Failed to create thread state for interpreter " << n << std::endl;
        return;
    }

    // 2. 将当前线程的活跃tstate切换为刚创建的ts
    PyThreadState_Swap(ts);

    // 3. 必须先获取GIL，才能执行后续的GIL相关操作
    PyEval_AcquireThread(ts);

    // 4. 保存线程状态并释放GIL，此时可以安全执行非Python代码
    PyThreadState* _save = PyEval_SaveThread();

    // --------------------------
    // 非Python并发执行代码（你的核心需求）
    std::cout << n << std::endl;
    // --------------------------

    // 5. 重新获取GIL并恢复线程状态
    PyEval_RestoreThread(_save);

    // 6. 释放GIL并清理线程状态
    PyEval_ReleaseThread(ts);
    PyThreadState_Clear(ts);
    PyThreadState_Delete(ts);

    return;
}

int main() {
    try {
        // 初始化Python环境
        Py_Initialize();
        // 初始化线程支持，主线程会自动持有GIL
        PyEval_InitThreads();

        // 保存主线程的原始线程状态
        PyThreadState* _main = PyThreadState_Get();
        // 保存主线程的GIL状态并释放GIL
        PyThreadState* main_save = PyEval_SaveThread();

        PyThreadState* i1 = nullptr;
        PyThreadState* i2 = nullptr;

        // 创建第一个子解释器：需要先重新获取GIL
        PyEval_RestoreThread(main_save);
        i1 = Py_NewInterpreter();
        // 切换回主线程的tstate，避免后续操作在子解释器上下文中执行
        PyThreadState_Swap(_main);
        // 释放GIL
        main_save = PyEval_SaveThread();

        // 创建第二个子解释器，重复相同的状态切换逻辑
        PyEval_RestoreThread(main_save);
        i2 = Py_NewInterpreter();
        PyThreadState_Swap(_main);
        main_save = PyEval_SaveThread();

        // 创建并启动子线程
        std::thread t1(worker, i1->interp, 1);
        std::thread t2(worker, i2->interp, 2);

        // 等待子线程完成
        t1.join();
        t2.join();

        // 清理子解释器：需要先获取GIL
        PyEval_RestoreThread(main_save);

        // 清理第一个子解释器
        PyThreadState_Swap(i1);
        Py_EndInterpreter(i1);

        // 清理第二个子解释器
        PyThreadState_Swap(i2);
        Py_EndInterpreter(i2);

        // 切换回主线程tstate并释放GIL
        PyThreadState_Swap(_main);
        PyEval_SaveThread();

        // 终止Python环境
        Py_Finalize();
        return 0;
    } catch(std::exception& e) {
        std::cout << "Exception:" << std::endl << e.what() << std::endl;
        // 异常情况下也要确保Python环境被正确清理
        if (Py_IsInitialized()) {
            Py_Finalize();
        }
        return 1;
    }
}

关键修正点总结 #

• 子线程必须先获取GIL：在调用PyEval_SaveThread()前，一定要用PyEval_AcquireThread(ts)获取GIL，确保线程持有GIL后再释放。
• 主线程及时切换回原始tstate：每次创建子解释器后，立刻用PyThreadState_Swap(_main)切回主线程状态，避免子解释器状态污染主线程操作。
• 严格匹配GIL的释放与恢复：GIL的操作必须成对出现，确保每个PyEval_SaveThread()都有对应的PyEval_RestoreThread()，反之亦然。
• 异常安全的清理：在catch块中加入Py_Finalize()的判断，避免Python环境未正确清理导致的资源泄漏。

这样修改后，多线程环境下子解释器与GIL的管理就会变得稳定，非Python代码的并发执行也能正常工作。

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