如何在C++程序中监控子脚本生成的文件并提取指定内容？

首先明确结论：你用tail -q -F --pid=<PID>的用法是正确的，分离线程运行tail也合理，但有更高效的实现方式，下面逐一拆解：

当前方案的问题与合理性 #

方案1的问题 #

你把主进程PID传给tail，虽然runMyScript()是阻塞调用，主进程会等脚本执行完再退出，tail也会跟着终止，但逻辑绕了一层——tail的生命周期应该和脚本进程绑定，而非主进程。另外，分离线程里的system()会额外创建子进程，虽然功能正常，但没必要多一层线程上下文切换。

方案2的改进点 #

方案2用fork启动脚本，把脚本PID传给tail，这个逻辑更合理，因为tail会在脚本进程退出时直接终止，不用等主进程。但你用execl("/bin/csh", "csh", "my_script", nullptr)属于多此一举：只要my_script有可执行权限且开头写了#!/bin/sh（或对应shell），直接execl("./my_script", "my_script", nullptr)就能启动，无需通过csh中转。

分离线程运行tail是否合理？ #

合理，但没必要。因为system()本身就会创建子进程，额外开线程只是增加了不必要的开销，直接用fork启动监控进程更轻量。

更优实现方案 #

方案A：轻量Shell依赖实现（推荐） #

直接用fork分别启动脚本和监控进程，无需C++线程，逻辑更清晰：

#include <iostream>
#include <fstream>
#include <unistd.h>
#include <sys/wait.h>
#include <string>

int main() {
    // 提前创建空文件，避免tail输出找不到文件的提示
    std::fstream("a.txt", std::fstream::out).close();

    // 启动脚本进程
    pid_t script_pid = fork();
    if (script_pid == 0) {
        // 直接执行脚本（需确保脚本有可执行权限+shebang）
        execl("./my_script", "my_script", nullptr);
        perror("启动脚本失败");
        _exit(1);
    } else if (script_pid < 0) {
        std::cerr << "fork脚本进程失败" << std::endl;
        return 1;
    }

    // 启动监控进程
    pid_t monitor_pid = fork();
    if (monitor_pid == 0) {
        // 用execlp调用tail，直接拼接参数，避免shell解析
        std::string pid_str = std::to_string(script_pid);
        execlp("tail", "tail", "-q", "-F", "--pid", pid_str.c_str(), "a.txt", nullptr);
        perror("启动tail失败");
        _exit(1);
    } else if (monitor_pid < 0) {
        std::cerr << "fork监控进程失败" << std::endl;
        // 先杀掉脚本进程再退出
        kill(script_pid, SIGTERM);
        waitpid(script_pid, nullptr, 0);
        return 1;
    }

    // 等待脚本执行完成
    int script_status;
    waitpid(script_pid, &script_status, 0);

    // 等待tail自动退出（因为--pid绑定了脚本进程，脚本结束tail就停）
    int monitor_status;
    waitpid(monitor_pid, &monitor_status, 0);

    return 0;
}

这个方案的优势：

• 无多余线程，开销更小
• 用execlp直接调用tail，避免shell解析命令字符串，更安全（如果文件名是动态生成的，能防止命令注入）
• 监控进程和脚本进程生命周期完全绑定，脚本结束监控立刻停止

方案B：纯C++无Shell依赖实现 #

如果不想依赖tail和grep，可以用Linux的inotifyAPI实现文件监控，纯C++代码处理：

#include <iostream>
#include <fstream>
#include <string>
#include <unistd.h>
#include <sys/inotify.h>
#include <sys/wait.h>
#include <thread>

#define BUF_SIZE 1024

void monitor_file(const std::string& filename, pid_t script_pid) {
    int inotify_fd = inotify_init();
    if (inotify_fd < 0) {
        perror("inotify初始化失败");
        return;
    }

    // 监听文件的修改和创建事件（防止脚本重建文件）
    int watch_fd = inotify_add_watch(inotify_fd, filename.c_str(), IN_MODIFY | IN_CREATE);
    if (watch_fd < 0) {
        perror("添加文件监听失败");
        close(inotify_fd);
        return;
    }

    std::ifstream file(filename);
    // 跳到文件末尾，只读取新增内容
    file.seekg(0, std::ios::end);

    char buf[BUF_SIZE];
    bool script_running = true;

    while (script_running) {
        // 非阻塞检查脚本是否还在运行
        if (waitpid(script_pid, nullptr, WNOHANG) != 0) {
            script_running = false;
            break;
        }

        // 读取inotify事件
        int len = read(inotify_fd, buf, BUF_SIZE);
        if (len < 0) {
            perror("读取inotify事件失败");
            break;
        }

        // 读取文件新增内容并过滤
        std::string line;
        while (std::getline(file, line)) {
            if (line.find("myText") != std::string::npos) {
                std::cout << line << std::endl;
            }
        }
        // 清除EOF标志，文件修改后可以继续读取
        file.clear();
    }

    inotify_rm_watch(inotify_fd, watch_fd);
    close(inotify_fd);
}

int main() {
    // 提前创建空文件
    std::fstream("a.txt", std::fstream::out).close();

    // 启动脚本进程
    pid_t script_pid = fork();
    if (script_pid == 0) {
        execl("./my_script", "my_script", nullptr);
        perror("启动脚本失败");
        _exit(1);
    } else if (script_pid < 0) {
        std::cerr << "fork脚本进程失败" << std::endl;
        return 1;
    }

    // 用线程运行监控函数，用join保证主线程等监控结束再退出
    std::thread monitor_thread(monitor_file, "a.txt", script_pid);
    monitor_thread.join();

    return 0;
}

这个方案的优势：

• 完全不依赖外部命令，跨平台性更好（Windows可替换为ReadDirectoryChangesW）
• 过滤逻辑完全自定义，支持更复杂的匹配规则
• 避免Shell命令带来的潜在安全问题

总结 #

1. 你用tail -F --pid的用法是正确的，--pid参数能确保tail在目标进程退出后自动终止
2. 分离线程运行tail是合理的，但直接用fork启动监控进程更高效
3. 优先推荐方案A（轻量且可靠），如果需要更高的灵活性和跨平台性，选方案B

内容的提问来源于stack exchange，提问作者Some random programmer