如何处理popen调用后引发fgets阻塞的外部程序冻结问题？

针对popen()调用外部程序时偶尔冻结导致阻塞的问题，同时满足跨Windows/Linux平台、长期运行数百万次调用的需求，以下是两种可靠的实现方案：

方案一：非阻塞管道读取+超时终止（推荐） #

核心思路是将popen（Windows下用CreateProcess模拟）返回的管道设置为非阻塞模式，配合超时等待机制读取数据，超时则强制终止外部程序，避免永久阻塞。该方案无需额外线程，资源开销低，适合高频调用场景。

跨平台实现代码 #

#include <iostream>
#include <string>
#include <array>
#include <memory>
#include <stdexcept>
#include <chrono>
#include <cstdio>

#ifdef _WIN32
#include <windows.h>
#include <io.h>
#else
#include <unistd.h>
#include <fcntl.h>
#include <sys/select.h>
#include <signal.h>
#include <sys/wait.h>
#endif

// Windows下：模拟popen并获取进程句柄
HANDLE createProcessWithPipe(const char* cmd, FILE** outPipe) {
    SECURITY_ATTRIBUTES saAttr = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
    HANDLE hChildStdoutRd, hChildStdoutWr;

    if (!CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0))
        throw std::runtime_error("CreatePipe failed");
    if (!SetHandleInformation(hChildStdoutRd, HANDLE_FLAG_INHERIT, 0))
        throw std::runtime_error("SetHandleInformation failed");

    STARTUPINFO si = {sizeof(STARTUPINFO)};
    si.hStdOutput = hChildStdoutWr;
    si.hStdError = hChildStdoutWr;
    si.dwFlags |= STARTF_USESTDHANDLES;

    PROCESS_INFORMATION pi = {0};
    std::string cmdLine = "cmd /c " + std::string(cmd);
    if (!CreateProcess(NULL, const_cast<char*>(cmdLine.c_str()), NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)) {
        CloseHandle(hChildStdoutRd);
        CloseHandle(hChildStdoutWr);
        throw std::runtime_error("CreateProcess failed");
    }

    CloseHandle(hChildStdoutWr);
    *outPipe = _fdopen(_open_osfhandle((intptr_t)hChildStdoutRd, _O_RDONLY), "r");
    if (!*outPipe) {
        CloseHandle(hChildStdoutRd);
        TerminateProcess(pi.hProcess, 1);
        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
        throw std::runtime_error("_fdopen failed");
    }

    CloseHandle(pi.hThread);
    return pi.hProcess;
}

// Linux下：获取popen创建的子进程PID
pid_t getPopenChildPid(FILE* pipe) {
    int fd = fileno(pipe);
    char path[256];
    snprintf(path, sizeof(path), "/proc/self/fdinfo/%d", fd);
    FILE* fdinfo = fopen(path, "r");
    if (!fdinfo) return -1;

    pid_t pid = -1;
    char line[256];
    while (fgets(line, sizeof(line), fdinfo)) {
        if (sscanf(line, "PeerPid: %d", &pid) == 1) break;
    }
    fclose(fdinfo);
    return pid;
}

// 带超时的外部程序调用函数
std::string execWithTimeout(const char* cmd, std::chrono::seconds timeout) {
    std::array<char, 128> buffer;
    std::string result;
    bool timedOut = false;

#ifdef _WIN32
    FILE* pipe = nullptr;
    HANDLE hProcess = createProcessWithPipe(cmd, &pipe);
    std::unique_ptr<FILE, decltype(&_pclose)> pipeGuard(pipe, _pclose);

    HANDLE hPipe = (HANDLE)_get_osfhandle(_fileno(pipe));
    DWORD mode = PIPE_NOWAIT;
    SetNamedPipeHandleState(hPipe, &mode, NULL, NULL); // 尝试设置非阻塞

    while (true) {
        DWORD waitRes = WaitForSingleObject(hPipe, timeout.count() * 1000);
        if (waitRes == WAIT_TIMEOUT) {
            timedOut = true;
            break;
        } else if (waitRes == WAIT_FAILED) {
            throw std::runtime_error("WaitForSingleObject failed");
        }

        size_t readLen = fgets(buffer.data(), buffer.size(), pipe);
        if (readLen == 0) {
            if (ferror(pipe)) throw std::runtime_error("fgets failed");
            break;
        }
        result += buffer.data();
    }

    if (timedOut) TerminateProcess(hProcess, 1);
    CloseHandle(hProcess);
#else
    std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd, "r"), pclose);
    if (!pipe) throw std::runtime_error("popen() failed!");

    int fd = fileno(pipe.get());
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
        throw std::runtime_error("fcntl set non-blocking failed");

    pid_t childPid = getPopenChildPid(pipe.get());
    if (childPid == -1) throw std::runtime_error("Get child PID failed");

    while (true) {
        fd_set readFds;
        FD_ZERO(&readFds);
        FD_SET(fd, &readFds);
        struct timeval tv = {static_cast<long>(timeout.count()), 0};

        int selectRes = select(fd + 1, &readFds, nullptr, nullptr, &tv);
        if (selectRes == -1) throw std::runtime_error("select failed");
        else if (selectRes == 0) {
            kill(-childPid, SIGKILL); // 杀掉整个进程组（含shell和外部程序）
            waitpid(childPid, nullptr, WNOHANG);
            timedOut = true;
            break;
        }

        ssize_t readLen = read(fd, buffer.data(), buffer.size() - 1);
        if (readLen == -1) {
            if (errno != EAGAIN && errno != EWOULDBLOCK)
                throw std::runtime_error("read failed");
            continue;
        } else if (readLen == 0) break;

        buffer[readLen] = '\0';
        result += buffer.data();
    }
#endif

    if (timedOut) throw std::runtime_error("External program timed out");
    return result;
}

int main() {
    try {
        // 设置5秒超时，可根据实际情况调整
        const std::string xmlResult = execWithTimeout("externalProgram --param1 --param2", std::chrono::seconds(5));
        // 处理XML结果
        std::cout << xmlResult << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}

方案说明 #

1. 跨平台兼容：
   • Windows下用CreateProcess模拟popen的shell调用逻辑，同时获取进程句柄，方便超时后终止。
   • Linux下直接使用popen，通过/proc文件系统获取子进程PID，超时后杀掉整个进程组（避免残留shell或外部程序进程）。
2. 非阻塞读取：配合select（Linux）或WaitForSingleObject（Windows）实现带超时的等待，避免永久阻塞。
3. 资源安全：通过智能指针自动管理管道，超时后强制终止子进程，无僵尸进程或资源泄漏问题，适合长期高频调用。

方案二：线程监控+超时终止（备选） #

若必须保留原popen调用逻辑，可采用线程执行读取、主线程监控超时的方案，但需注意线程资源回收：

• 每次调用启动一个线程，线程内执行原exec函数的读取逻辑。
• 主线程用std::future或条件变量等待线程完成，超时则触发子进程终止逻辑，线程退出后自动回收资源。
• 该方案线程创建销毁有一定开销，适合调用频率较低的场景，高频调用优先选择方案一。

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