Linux下在std::thread中创建子进程的可行替代方案咨询

我有一个基于C++开发的Windows平台浏览器扩展原生程序，核心逻辑如下：

• 通过stdin接收浏览器发来的下载URL
• 通过stdout返回下载进度/完成状态给浏览器

原Windows平台程序流程：

1. 主循环持续读取stdin，接收浏览器消息；
2. 每条消息触发主循环创建一个std::thread，传入待下载URL后启动线程，主循环继续监听新消息；
3. 线程内通过CreateProcess()启动curl.exe子进程，持续读取其输出；
4. 线程通过带std::lock_guard<std::mutex>保护的函数将进度写入stdout，避免多线程写入冲突。

现在要移植到Linux平台，原本想直接用popen()替代CreateProcess()，但发现popen底层依赖fork()，而fork()在多线程环境下不安全（只会复制当前线程，其他线程在子进程中消失，可能导致锁状态不一致等问题）。如果用常规的fork()+管道方案，又要大幅改动现有基于线程的结构，不清楚如何在维持主循环的同时读取所有子进程管道输出，若用线程处理管道又回到fork()的线程安全问题。

请问有没有其他可行的实现方式？

#include <iostream>
#include <thread>
#include <mutex>
#include <string>
#include <cstdio>
#include <windows.h>

std::mutex theMutex;
const size_t message_length = 1024; // 假设消息长度固定为1024

void write_to_stdout(const std::string& msg)
{
    std::lock_guard<std::mutex> lock(theMutex);
    
    const unsigned int len = msg.length();
    fwrite(msg.c_str(), sizeof(char), len, stdout);
    fflush(stdout);
}

void download_thread(const std::string& url)
{
    STARTUPINFOW siStartInfo = {0};
    PROCESS_INFORMATION piProcInfo = {0};
    siStartInfo.cb = sizeof(STARTUPINFOW);
    siStartInfo.dwFlags |= STARTF_USESTDHANDLES;

    // 假设已创建管道并设置好子进程stdout读取句柄
    HANDLE h_child_stdout_r = nullptr;

    /* 创建curl进程 */
    BOOL bSuccess = CreateProcessW(
            L"curl.exe",
            (L"curl.exe " + std::wstring(url.begin(), url.end())).c_str(),
            NULL,
            NULL,
            TRUE,
            0,
            NULL,
            NULL,
            &siStartInfo,
            &piProcInfo);
    
    if (!bSuccess) {
        write_to_stdout("Failed to start curl process\n");
        return;
    }

    /* 持续读取子进程输出直到退出 */
    const int BUFSIZE = 1024;
    char buf[BUFSIZE];
    DWORD bytesRead = 0;

    while(true)
    {
        bSuccess = ReadFile(h_child_stdout_r, buf, BUFSIZE, &bytesRead, NULL);

        if(!bSuccess || bytesRead <= 0)
        {
            break;
        }
        
        std::string output(buf, buf + bytesRead);
        write_to_stdout(output);
    }

    // 清理资源
    CloseHandle(piProcInfo.hProcess);
    CloseHandle(piProcInfo.hThread);
    CloseHandle(h_child_stdout_r);
}

int main()
{
    while(true)
    {
        char* url_buf = new char[message_length];
        size_t read_bytes = fread(url_buf, sizeof(char), message_length, stdin);
        if (read_bytes <= 0) break;
        
        std::string url(url_buf, read_bytes);
        delete[] url_buf;
        
        std::thread th1(download_thread, url);
        th1.detach();
    }
    
    return 0;
}

1. 使用posix_spawn()替代fork()/popen() #

posix_spawn()是POSIX标准的进程创建接口，相比fork()更适合多线程环境：它不需要复制整个进程地址空间，直接创建新进程并执行指定程序，从根源避免了fork()带来的线程安全问题。

实现逻辑和Windows下的CreateProcess()+管道几乎一致，改动最小：

• 在下载线程中创建匿名管道（pipe()）；
• 配置posix_spawn_file_actions_t，将子进程的stdout重定向到管道写端；
• 调用posix_spawn()启动curl，传入URL参数；
• 关闭管道写端，在线程中从管道读端持续读取curl输出，处理后通过write_to_stdout()发送给浏览器；
• 最后调用waitpid()等待子进程结束，清理资源。

示例代码片段：

#include <unistd.h>
#include <spawn.h>
#include <sys/wait.h>
#include <cstdlib>

void download_thread(const std::string& url) {
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        write_to_stdout("Failed to create pipe\n");
        return;
    }

    posix_spawn_file_actions_t file_actions;
    posix_spawn_file_actions_init(&file_actions);
    // 将子进程stdout重定向到管道写端
    posix_spawn_file_actions_adddup2(&file_actions, pipefd[1], STDOUT_FILENO);
    // 关闭子进程中不需要的管道描述符
    posix_spawn_file_actions_addclose(&file_actions, pipefd[0]);
    posix_spawn_file_actions_addclose(&file_actions, pipefd[1]);

    const char* argv[] = {"curl", url.c_str(), nullptr};
    pid_t pid;
    int ret = posix_spawn(&pid, "/usr/bin/curl", &file_actions, nullptr, const_cast<char**>(argv), environ);
    
    // 关闭当前线程中的管道写端
    close(pipefd[1]);

    if (ret != 0) {
        close(pipefd[0]);
        posix_spawn_file_actions_destroy(&file_actions);
        write_to_stdout("Failed to start curl process\n");
        return;
    }

    // 读取子进程输出
    const int BUFSIZE = 1024;
    char buf[BUFSIZE];
    ssize_t bytesRead;
    while ((bytesRead = read(pipefd[0], buf, BUFSIZE)) > 0) {
        std::string output(buf, bytesRead);
        write_to_stdout(output);
    }

    // 等待子进程结束
    int status;
    waitpid(pid, &status, 0);

    close(pipefd[0]);
    posix_spawn_file_actions_destroy(&file_actions);
}

2. 直接使用libcurl库（推荐） #

既然核心是调用curl下载，完全可以跳过启动子进程的方式，直接在C++代码中链接libcurl库，通过其API实现下载进度回调。这种方式既避免了进程创建的问题，又能更灵活地控制下载过程，减少进程间通信开销。

步骤：

• Linux下安装libcurl开发库：sudo apt-get install libcurl4-openssl-dev（Debian/Ubuntu）或对应发行版的包管理命令；
• 在下载线程中初始化curl句柄，设置URL、进度回调函数；
• 进度回调函数中直接调用write_to_stdout()发送进度信息；
• 执行curl请求，完成后清理句柄。

示例代码片段：

#include <curl/curl.h>

// 进度回调函数，curl会在下载过程中多次调用此函数
static int progress_callback(void* ptr, curl_off_t dl_total, curl_off_t dl_now, curl_off_t ul_total, curl_off_t ul_now) {
    if (dl_total > 0) {
        double progress = (double)dl_now / dl_total * 100;
        std::string msg = "Download progress: " + std::to_string(progress) + "%\n";
        write_to_stdout(msg);
    }
    return 0; // 返回0表示继续下载
}

void download_thread(const std::string& url) {
    CURL* curl = curl_easy_init();
    if (!curl) {
        write_to_stdout("Failed to initialize curl\n");
        return;
    }

    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L); // 启用进度回调
    curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, progress_callback);

    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        std::string err_msg = "Download failed: " + std::string(curl_easy_strerror(res)) + "\n";
        write_to_stdout(err_msg);
    } else {
        write_to_stdout("Download completed successfully\n");
    }

    curl_easy_cleanup(curl);
}

// 主函数中需要全局初始化curl
int main() {
    curl_global_init(CURL_GLOBAL_ALL);
    
    while(true) {
        char* url_buf = new char[message_length];
        size_t read_bytes = fread(url_buf, sizeof(char), message_length, stdin);
        if (read_bytes <= 0) break;
        
        std::string url(url_buf, read_bytes);
        delete[] url_buf;
        
        std::thread th1(download_thread, url);
        th1.detach();
    }

    curl_global_cleanup();
    return 0;
}

3. 使用system()（备选，不推荐） #

如果只是临时快速移植，且对下载进度实时性要求不高，可以用system()调用curl命令，将输出重定向到临时文件，线程中读取临时文件内容。但这种方式无法实时获取进度，且临时文件管理容易出问题，仅适合简单场景。

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