看起来你遇到的问题是用pybind11执行Python无限循环时，超时中断完全不起作用——这其实是几个pybind11和Python线程交互的常见坑导致的，我来帮你一步步梳理解决。

首先先拆解你当前代码的核心问题：

1. PyErr_SetInterrupt必须持有GIL才能生效：你的主线程启动Python线程后调用了py::gil_scoped_release释放了GIL，之后调用PyErr_SetInterrupt时根本没持有GIL，这个调用不会被Python运行时正确处理，自然触发不了中断。
2. 异常处理覆盖不全：Python的KeyboardInterrupt是特殊异常，pybind11会把它包装成py::error_already_set，虽然它继承自std::exception，但显式捕获能更可靠地处理中断场景。

接下来给你两个可行的解决方案，从简单修复现有逻辑到更健壮的生产级实现：

方案一：修复线程方案，正确触发Python中断 #

调整你的超时检查逻辑，确保调用Python中断API时持有GIL，同时优化异常处理流程：

#include <fstream>
#include <iostream>
#include <string>
#include <thread>
#include <atomic>
#include <chrono>
#include <cstdlib>
#include "pybind11/pybind11.h"
#include "pybind11/embed.h"

namespace py = pybind11;

std::atomic<bool> stopped(false);
std::atomic<bool> executed(false);

void python_executor(const std::string &code) {
    py::gil_scoped_acquire acquire;
    try {
        std::cout << "+ Executing python script..." << std::endl;
        py::exec(code);
        std::cout << "+ Finished python script" << std::endl;
    } catch (const py::error_already_set &e) {
        // 显式捕获Python异常，专门处理KeyboardInterrupt
        if (e.matches(PyExc_KeyboardInterrupt)) {
            std::cout << "@ Python execution interrupted by timeout" << std::endl;
        } else {
            std::cout << "@ Python error: " << e.what() << std::endl;
        }
    } catch (const std::exception &e) {
        std::cout << "@ C++ exception: " << e.what() << std::endl;
    }
    executed = true;
    std::cout << "+ Terminated normal" << std::endl;
}

int main() {
    std::cout << "+ Starting..." << std::endl;
    std::string code = R"(
import time
file_path = r"C:\Temp\loop.txt"
counter = 1
while True:
    with open(file_path, "a") as f:
        f.write(f"Line {counter}\n")
    counter += 1
    time.sleep(1)
)";

    py::scoped_interpreter interpreterGuard{};
    // 主线程先释放GIL，让子线程能正常获取
    py::gil_scoped_release release;

    std::thread th(python_executor, code);
    auto threadId = th.get_id();
    std::cout << "+ Thread: " << threadId << std::endl;

    int maxExecutionTime = 10;
    auto start = std::chrono::steady_clock::now();
    while (!executed) {
        auto elapsed = std::chrono::steady_clock::now() - start;
        if (elapsed > std::chrono::seconds(maxExecutionTime)) {
            std::cout << "Interrupting...";
            // 关键：重新获取GIL再调用Python中断API
            py::gil_scoped_acquire acquire;
            PyErr_SetInterrupt();
            // 主动释放GIL，让子线程有机会处理中断信号
            acquire.release();
            
            // 等待一小段时间让线程处理中断，再检查是否可join
            std::this_thread::sleep_for(std::chrono::seconds(1));
            if (th.joinable()) {
                th.join();
                executed = true;
                break;
            }
        }
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << "+ Waiting..." << std::endl;
    }

    if (th.joinable()) {
        th.join();
    }
    std::cout << "+ Finished" << std::endl;
    return EXIT_SUCCESS;
}

核心修改点： #

• 触发中断时通过py::gil_scoped_acquire重新获取GIL，保证PyErr_SetInterrupt能被Python运行时识别
• 显式捕获py::error_already_set，专门处理KeyboardInterrupt中断场景
• 调用中断后主动释放GIL，让Python子线程有机会处理中断信号

方案二：用子进程代替线程（更健壮的强制终止） #

如果你的场景需要绝对强制的终止（比如Python代码是纯CPU密集型循环，没有time.sleep这类会触发信号检查的操作），线程方案就不太靠谱了——因为C++和Python都不支持安全强制终止线程（会导致资源泄漏、死锁等问题）。这时候用子进程是更稳妥的选择：

思路： #

1. 将Python代码写入临时脚本文件
2. 启动独立子进程执行脚本
3. 主线程监控运行时间，超时直接杀死子进程
4. 清理临时文件和进程资源

示例代码（Windows平台，Linux可替换为fork+kill逻辑）：

#include <iostream>
#include <string>
#include <chrono>
#include <cstdlib>
#include <thread>
#include <fstream>
#include <windows.h>

int main() {
    std::cout << "+ Starting..." << std::endl;
    std::string code = R"(
import time
file_path = r"C:\Temp\loop.txt"
counter = 1
while True:
    with open(file_path, "a") as f:
        f.write(f"Line {counter}\n")
    counter += 1
    time.sleep(1)
)";

    // 将Python代码写入临时脚本
    std::ofstream temp_script("temp_py_script.py");
    temp_script << code;
    temp_script.close();

    // 启动子进程执行脚本
    STARTUPINFO si = {0};
    PROCESS_INFORMATION pi = {0};
    std::string cmd = "python temp_py_script.py";
    if (!CreateProcessA(NULL, (LPSTR)cmd.c_str(), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
        std::cerr << "Failed to start Python process" << std::endl;
        remove("temp_py_script.py");
        return EXIT_FAILURE;
    }

    int maxExecutionTime = 10;
    auto start = std::chrono::steady_clock::now();
    bool timed_out = false;

    while (true) {
        auto elapsed = std::chrono::steady_clock::now() - start;
        if (elapsed > std::chrono::seconds(maxExecutionTime)) {
            std::cout << "Killing process due to timeout..." << std::endl;
            TerminateProcess(pi.hProcess, 1);
            timed_out = true;
            break;
        }

        // 检查进程是否已正常退出
        DWORD exit_code;
        if (GetExitCodeProcess(pi.hProcess, &exit_code) && exit_code != STILL_ACTIVE) {
            std::cout << "Process finished normally" << std::endl;
            break;
        }

        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << "+ Waiting..." << std::endl;
    }

    // 清理资源
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
    remove("temp_py_script.py");

    std::cout << "+ Finished" << std::endl;
    return timed_out ? EXIT_FAILURE : EXIT_SUCCESS;
}

为什么这个方案更可靠？ #

• 子进程有独立的地址空间，强制杀死不会影响主线程稳定性
• 不管Python代码是否响应中断，都能确保超时后终止
• 适合处理不可信的Python代码（比如用户上传的自定义脚本）

额外注意事项 #

• 如果Python代码是纯CPU密集型（没有time.sleep、input等触发信号检查的操作），PyErr_SetInterrupt可能不会立即生效——因为Python只会在字节码执行的间隙检查中断，这种情况下子进程方案是唯一可靠的选择。
• 也可以尝试用PyEval_AsyncStop()替代PyErr_SetInterrupt()，它的终止力度更强，但同样需要持有GIL才能调用，且依赖Python运行时的检查点。