UNIX系统下基于文件名实现公共文件并行读写同步的性能优化方案咨询

嘿，你的这个文件重命名同步思路虽然能跑通，但性能拉胯是必然的——咱们先拆解下原方案的问题：

• 你用忙等循环不断检查文件是否存在，这会让CPU空转，浪费大量资源；
• 文件系统的操作（创建、打开、重命名）本身就是相对高开销的IO操作，每次同步都走文件系统，0.5ms的耗时其实很合理，但完全没必要这么做。

针对线程间的场景，咱们直接用C++标准库的同步原语就能搞定，性能会提升一大截；如果是真正的进程间同步，也有更高效的IPC方案，下面分别说：

一、线程间同步：用std::mutex + std::condition_variable（最优解） #

线程属于同一个进程，共享地址空间，直接用标准库的同步工具就足够高效，完全不需要碰文件系统。这里给你改个示例代码：

#include <iostream>
#include <fstream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool is_main_turn = true; // 标记当前轮到哪个主体写入

void thread_writer() {
    std::ofstream file("common.txt", std::ios_base::app);
    if (!file.is_open()) {
        std::cerr << "Failed to open file!" << std::endl;
        return;
    }

    for (int ii = 0; ii < 10; ++ii) {
        std::unique_lock<std::mutex> lock(mtx);
        // 等待轮到线程写入
        cv.wait(lock, []{ return !is_main_turn; });

        // 写入操作
        file << "hello from thread" << std::endl;

        // 切换权限，通知主线程
        is_main_turn = true;
        cv.notify_one();
    }
    file.close();
}

int main(int argc, char *argv[]) {
    // 先清空文件（如果需要）
    std::ofstream file("common.txt", std::ios_base::trunc);
    file.close();

    std::thread th(thread_writer);

    std::ofstream main_file("common.txt", std::ios_base::app);
    if (!main_file.is_open()) {
        std::cerr << "Failed to open file!" << std::endl;
        th.join();
        return 1;
    }

    for (int ii = 0; ii < 10; ++ii) {
        std::unique_lock<std::mutex> lock(mtx);
        // 等待轮到主线程写入
        cv.wait(lock, []{ return is_main_turn; });

        // 写入操作
        main_file << "hello from main" << std::endl;

        // 切换权限，通知线程
        is_main_turn = false;
        cv.notify_one();
    }
    main_file.close();

    th.join();
    return 0;
}

这个方案的优势：

• 没有忙等，线程等待时会进入休眠，不会占用CPU；
• 同步操作都是内存级别的，开销极低，单次写入耗时会降到微秒级甚至更低；
• 逻辑更清晰，直接标记权限归属，不需要依赖文件系统的状态。

二、进程间同步：用命名同步原语 #

如果是真正的跨进程场景（不是同一个进程内的线程），可以用命名互斥量或命名条件变量，不同进程可以通过同一个名称来访问这些同步对象：

Linux平台 #

可以用pthread库的共享互斥量，设置PTHREAD_PROCESS_SHARED属性，或者用系统提供的命名信号量：

#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <fstream>
#include <iostream>

int main() {
    // 创建命名信号量，初始值为1（表示当前进程先拥有权限）
    sem_t* sem = sem_open("/file_write_sem", O_CREAT | O_EXCL, 0644, 1);
    if (sem == SEM_FAILED) {
        // 如果信号量已存在，打开它
        sem = sem_open("/file_write_sem", 0);
    }

    std::ofstream file("common.txt", std::ios_base::app);
    for (int i = 0; i < 10; ++i) {
        sem_wait(sem); // 等待获取权限
        file << "hello from process A" << std::endl;
        sem_post(sem); // 释放权限给另一个进程
    }

    sem_close(sem);
    sem_unlink("/file_write_sem"); // 用完销毁
    file.close();
    return 0;
}

Windows平台 #

可以用CreateMutexW创建命名互斥量，不同进程通过同一个名称打开它：

#include <windows.h>
#include <fstream>
#include <iostream>

int main() {
    HANDLE hMutex = CreateMutexW(NULL, FALSE, L"Global\\FileWriteMutex");
    if (hMutex == NULL) {
        std::cerr << "CreateMutex failed!" << std::endl;
        return 1;
    }

    std::ofstream file("common.txt", std::ios_base::app);
    for (int i = 0; i < 10; ++i) {
        WaitForSingleObject(hMutex, INFINITE); // 获取权限
        file << "hello from process A" << std::endl;
        ReleaseMutex(hMutex); // 释放权限
    }

    CloseHandle(hMutex);
    file.close();
    return 0;
}

总结一下 #

• 线程间同步：优先用std::mutex+std::condition_variable，性能最高，逻辑最清晰；
• 进程间同步：用命名互斥量/信号量，比文件重命名高效得多；
• 原方案的核心问题是忙等+文件系统IO开销，这两个点都是性能杀手，换掉之后性能会有质的提升。

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