在C++中同时启动Python2.7与Python3.9解释器可行性咨询

核心限制说明 #

同一个进程内直接加载Python2.7和Python3.9的官方库会触发全局符号冲突（比如两个版本都导出Py_Initialize、Py_Finalize等同名函数），因此必须通过以下方式规避：

方案1：进程隔离（最推荐，稳定性最高） #

将Python2.7和Python3.9的调用逻辑拆分到独立的子进程中，C++主进程通过IPC（管道、共享内存、本地Socket）与子进程交互数据。这种方式完全隔离两个解释器的运行环境，不会有任何冲突。

简化实现示例（Linux/macOS） #

1. 编写两个独立的C++辅助程序，分别嵌入Python2.7和Python3.9：

   • 针对Python2.7的程序py2_worker.cpp：

     #include <Python.h>
     #include <iostream>
     #include <string>
     
     int main() {
         Py_Initialize();
         // 设置Python2的模块路径
         PyRun_SimpleString("import sys; sys.path.append('/path/to/py2_modules')");
         // 读取stdin输入，执行Python2模块逻辑并输出结果到stdout
         std::string input;
         std::getline(std::cin, input);
         PyObject* module = PyImport_ImportModule("your_py2_module");
         PyObject* func = PyObject_GetAttrString(module, "target_func");
         PyObject* args = PyTuple_New(1);
         PyTuple_SetItem(args, 0, PyString_FromString(input.c_str()));
         PyObject* res = PyObject_CallObject(func, args);
         char* res_str;
         PyString_AsStringAndSize(res, &res_str, nullptr);
         std::cout << res_str << std::endl;
         // 清理资源
         Py_DECREF(args);
         Py_DECREF(func);
         Py_DECREF(module);
         Py_Finalize();
         return 0;
     }
     

     编译时链接Python2.7库：g++ py2_worker.cpp -o py2_worker -lpython2.7

   • 针对Python3.9的程序py3_worker.cpp逻辑类似，仅替换头文件和链接库：g++ py3_worker.cpp -o py3_worker -lpython3.9

2. 主C++程序通过fork()/exec()启动子进程，用管道传递数据：

   #include <iostream>
   #include <unistd.h>
   #include <sys/wait.h>
   #include <string>
   
   std::string run_python_worker(const std::string& worker_path, const std::string& input) {
       int pipe_in[2], pipe_out[2];
       pipe(pipe_in);
       pipe(pipe_out);
       pid_t pid = fork();
       if (pid == 0) {
           // 子进程重定向标准IO到管道
           dup2(pipe_in[0], STDIN_FILENO);
           dup2(pipe_out[1], STDOUT_FILENO);
           close(pipe_in[1]);
           close(pipe_out[0]);
           execl(worker_path.c_str(), worker_path.c_str(), nullptr);
           exit(1);
       }
       // 主进程发送输入、读取输出
       close(pipe_in[0]);
       close(pipe_out[1]);
       write(pipe_in[1], input.c_str(), input.size());
       close(pipe_in[1]);
       char buffer[1024];
       ssize_t bytes_read = read(pipe_out[0], buffer, sizeof(buffer)-1);
       buffer[bytes_read] = '\0';
       waitpid(pid, nullptr, 0);
       return std::string(buffer);
   }
   
   int main() {
       // 调用Python2模块
       std::string py2_result = run_python_worker("./py2_worker", "test_input");
       // 调用Python3模块
       std::string py3_result = run_python_worker("./py3_worker", "test_input");
       std::cout << "Py2 result: " << py2_result << "\nPy3 result: " << py3_result << std::endl;
       return 0;
   }
   

方案2：修改Python库符号命名（进程内可行，复杂度高） #

如果必须在同一个进程内调用两个版本的Python，需要对其中一个版本的Python库（比如Python2.7）进行重编译，将所有全局符号添加自定义前缀（如Py2_），避免与Python3的符号冲突。

关键步骤： #

1. 下载Python2.7源码，修改Include/pyport.h中的宏定义，将PyAPI_FUNC、PyAPI_DATA的符号前缀替换为Py2_，同时批量替换源码中所有全局函数/变量的名称（比如Py_Initialize改为Py2_Initialize）。
2. 重新编译Python2.7库，得到带有自定义符号的libpython2.7_custom.so。
3. 在C++主程序中分别链接修改后的Python2库和官方Python3库，分别初始化两个解释器：

   #include <Python.h> // Python3.9的头文件
   #include "Python2.h" // 修改后的Python2.7头文件
   
   int main() {
       // 初始化Python2.7
       Py2_Initialize();
       Py2Run_SimpleString("import sys; sys.path.append('/path/to/py2_modules')");
       // 初始化Python3.9
       Py_Initialize();
       PyRun_SimpleString("import sys; sys.path.append('/path/to/py3_modules')");
   
       // 分别调用两个版本的模块，注意GIL的单独管理
       PyGILState_STATE py2_gil = Py2GILState_Ensure();
       // 执行Python2逻辑
       Py2GILState_Release(py2_gil);
   
       PyGILState_STATE py3_gil = PyGILState_Ensure();
       // 执行Python3逻辑
       PyGILState_Release(py3_gil);
   
       Py2_Finalize();
       Py_Finalize();
       return 0;
   }
   

   注意：这种方式需要处理大量源码修改和编译问题，且容易出现内存管理、GIL冲突等隐性bug，仅适合必须进程内运行的场景。

避坑要点 #

• GIL管理：两个解释器的GIL是独立的，必须分别调用对应版本的GIL获取/释放函数，不能交叉操作。
• 模块路径隔离：务必为每个解释器单独设置sys.path，避免加载错误版本的模块。
• 数据序列化：进程间或跨解释器传递数据时，必须使用JSON、字符串等通用格式，不能直接传递Python对象指针（内存空间不共享）。

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