C++进程间同步问题：多EXE实例的文件生成与读取协同

一、标准C++的进程间同步支持 #

标准C在C20之前没有原生的进程间同步机制。C20引入的<semaphore>头文件中的信号量默认仅支持线程间同步，若要实现进程间共享，需配合共享内存机制，实现繁琐且跨平台兼容性有限，实际项目中很少直接依赖标准C完成进程间同步。

二、实用实现方案 #

1. 基于文件锁的跨平台方案（推荐） #

利用文件系统的原子性操作实现同步，这是最通用的跨平台方式：

• 执行步骤：
  • 所有实例尝试创建临时锁文件（比如目标目录/.sync_lock），使用排他创建模式（文件已存在则创建失败）。
  • 创建成功的实例（获得锁）：执行文件生成逻辑，完成后删除锁文件。
  • 创建失败的实例：循环检查锁文件是否存在，直到锁文件被删除，再执行读取逻辑。
• 关键注意点：
  • 需处理异常场景（如生成实例崩溃导致锁文件残留），可给锁文件添加超时判断（记录创建时间，超过阈值则强制删除）。
  • 平台适配：Windows用CreateFile的CREATE_NEW标志；Linux/macOS用open函数的O_CREAT | O_EXCL标志实现排他创建。
• 伪代码示例：

#include <fstream>
#include <chrono>
#include <thread>
#include <filesystem>

namespace fs = std::filesystem;

bool try_acquire_lock(const fs::path& lock_path) {
    // 依赖文件系统排他创建特性，部分平台需调整打开参数
    std::ofstream lock_file(lock_path, std::ios::out | std::ios::binary);
    return lock_file.is_open();
}

void release_lock(const fs::path& lock_path) {
    fs::remove(lock_path);
}

void process_target_dir(const fs::path& target_dir) {
    const fs::path lock_path = target_dir / ".sync_lock";
    bool has_lock = false;

    // 循环尝试获取锁，失败则短暂等待后重试
    while (!has_lock) {
        has_lock = try_acquire_lock(lock_path);
        if (!has_lock) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            // 可选：添加超时逻辑，避免无限等待
        }
    }

    try {
        if (fs::is_empty(target_dir)) {
            // 执行文件生成逻辑
            generate_files(target_dir);
        }
        // 无论是否生成文件，都要释放锁
        release_lock(lock_path);
    } catch (...) {
        release_lock(lock_path);
        throw;
    }

    // 所有实例到此处均可安全读取文件
    read_files_and_populate(target_dir);
}

2. 平台特定同步原语 #

Windows平台：命名互斥量

使用Windows原生的命名互斥量实现进程间同步：

#include <windows.h>

void process_target_dir(const std::wstring& target_dir) {
    // 全局命名空间可跨会话访问，避免同名冲突
    HANDLE hMutex = CreateMutexW(NULL, FALSE, L"Global\\MyAppFileSyncMutex");
    if (hMutex == NULL) {
        // 处理创建错误
        return;
    }

    // 等待互斥量可用
    DWORD waitResult = WaitForSingleObject(hMutex, INFINITE);
    if (waitResult != WAIT_OBJECT_0) {
        CloseHandle(hMutex);
        return;
    }

    try {
        if (IsDirectoryEmpty(target_dir)) {
            GenerateFiles(target_dir);
        }
    } finally {
        ReleaseMutex(hMutex);
        CloseHandle(hMutex);
    }

    ReadFilesAndPopulate(target_dir);
}

Linux/macOS平台：命名信号量

通过sem_open创建跨进程信号量：

#include <semaphore.h>
#include <fcntl.h>
#include <unistd.h>

void process_target_dir(const std::string& target_dir) {
    // 初始值设为1，O_EXCL确保只有第一个进程能创建
    sem_t* sem = sem_open("/myapp_file_sync_sem", O_CREAT | O_EXCL, 0644, 1);
    if (sem == SEM_FAILED) {
        // 信号量已存在，直接打开
        sem = sem_open("/myapp_file_sync_sem", 0);
        if (sem == SEM_FAILED) {
            // 处理打开错误
            return;
        }
    }

    // 等待信号量
    sem_wait(sem);

    try {
        if (is_directory_empty(target_dir)) {
            generate_files(target_dir);
        }
    } finally {
        sem_post(sem);
        sem_close(sem);
        // 仅创建信号量的进程需要执行unlink，避免系统资源残留
        if (errno != EEXIST) {
            sem_unlink("/myapp_file_sync_sem");
        }
    }

    read_files_and_populate(target_dir);
}

三、核心注意事项 #

• 原子性：所有同步操作必须保证原子性，避免多个实例同时进入文件生成逻辑。
• 异常安全：无论生成过程是否抛出异常，都必须释放同步锁/信号量，防止其他实例永久等待。
• 资源清理：平台特定同步原语（如Windows互斥量、Linux信号量）需确保不会残留系统资源，影响后续运行。

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