OpenMP中如何正确实现stdout按线程重定向到专属输出文件

现有实现存在两个核心问题，直接导致重定向失效：

• std::cout是进程级全局共享的单例流对象，所有线程操作的都是同一个实例。在OpenMP并行区中调用cout.rdbuf(...)修改的是这个全局对象的内部缓冲区指针，多个线程同时修改这个指针时会产生数据竞争，属于C++标准定义的未定义行为。
• 就算没有竞争，这种全局属性的修改对所有线程生效：一个线程把cout的缓冲区切到自己的日志文件时，其他线程的cout输出也会跟着被导向这个文件，根本做不到线程级的输出隔离。

观察到的输出不对称、部分日志为空的现象，就是多线程互相覆盖修改cout的rdbuf指针导致的。

最稳妥、性能损耗最低的方法是替换cout的底层路由缓冲区，把原本直接写stdout的逻辑，改成根据当前输出线程的ID，自动路由到对应专属日志文件的缓冲区。这种方法不需要修改原有业务代码里的cout调用逻辑，也没有锁的额外开销。

实现步骤 #

1. 自定义一个继承自std::streambuf的路由缓冲区，内部维护一个数组，存每个线程ID对应的文件流缓冲区。所有写入cout的字符都会被这个缓冲区拦截，然后根据当前线程ID写入对应的目标文件。
2. 程序启动时，一次性把所有线程的日志文件打开，把每个线程的缓冲区注册到路由层。
3. 把cout的原始stdout缓冲区保存下来，将cout的底层缓冲区替换成自定义的路由层。
4. 并行执行业务逻辑，所有cout输出会被自动路由到对应线程的日志文件，不需要在并行区内做任何流切换操作。
5. 所有并行任务执行完成后，把cout的缓冲区换回原始的stdout即可。

适配现有环境的代码示例 #

#include <omp.h>
#include <vector>
#include <iostream>
#include <fstream>
#include <math.h>
#include <cstdio>
#include <cstring>

using namespace std;

// 自定义路由流缓冲区：根据当前线程ID把输出路由到对应文件
class ThreadRouteBuf : public std::streambuf {
private:
    vector<streambuf*> thread_buf_list;
public:
    ThreadRouteBuf(int max_threads) : thread_buf_list(max_threads, nullptr) {}

    // 注册指定线程对应的输出缓冲区
    void register_thread_buf(int thread_id, streambuf* buf) {
        if (thread_id >= 0 && thread_id < (int)thread_buf_list.size()) {
            thread_buf_list[thread_id] = buf;
        }
    }

protected:
    // 拦截所有写入cout的单个字符
    virtual int overflow(int c) {
        int tid = omp_get_thread_num();
        if (tid < (int)thread_buf_list.size() && thread_buf_list[tid] != nullptr) {
            if (c != EOF) {
                return thread_buf_list[tid]->sputc(c);
            }
        }
        return EOF;
    }

    // 拦截flush操作，刷新当前线程对应的缓冲区
    virtual int sync() {
        int tid = omp_get_thread_num();
        int ret = 0;
        if (tid < (int)thread_buf_list.size() && thread_buf_list[tid] != nullptr) {
            ret = thread_buf_list[tid]->pubsync();
        }
        return ret;
    }
};

double calc1() {
  const int MAXIT=100000000;
  double x,res = 0.0;
  int thread_id = omp_get_thread_num();
  for (int j=0; j<10; j++) {
    for (int i=0; i<MAXIT; i++) {
      x = i;
      x = sqrt(x);
    }
    res += x*x;
    cout << " thread_id = " << thread_id << " j = " << j << endl; 
  }
  return res;
}

int main(int argc, char* argv[]){
  int nThreads;
  int nThreadsMax = omp_get_max_threads();

  if (argc==1) {
    nThreads = nThreadsMax;
  }
  else {
    nThreads = atoi(argv[1]);
  }
  cout << "using " << nThreads << " threads" << endl;
  
  // 打开每个线程对应的日志文件，直接存储对象避免指针泄漏
  vector<ofstream> log_files;
  char filename[32];
  for (int nt=0; nt<nThreads; nt++) {
    sprintf(filename, "thr_%d.log", nt);
    log_files.push_back(ofstream(filename));
  }
  
  omp_set_num_threads(nThreads);
 
  // 初始化路由缓冲区，注册每个线程对应的文件流
  ThreadRouteBuf route_buf(nThreads);
  for (int nt=0; nt<nThreads; nt++) {
    route_buf.register_thread_buf(nt, log_files[nt].rdbuf());
  }

  // 保存cout的原始stdout缓冲区，临时替换成路由缓冲区
  streambuf* original_cout_buf = cout.rdbuf();
  cout.rdbuf(&route_buf);

  // 并行执行计算，不需要任何流切换操作
#pragma omp parallel for
  for (int nt=0; nt<nThreads; nt++) {
    double res = calc1();
    cout << "nt = " << nt << " res = " << res << endl;
  }

  // 所有任务完成，恢复cout的原始输出
  cout.rdbuf(original_cout_buf);

  return 0;
}

• 完全兼容原有业务逻辑，不需要修改calc1里的cout输出代码，改造成本极低
• 没有锁开销：每个线程写入时只根据自己的线程ID找到对应的缓冲区，不存在共享数据竞争，并行性能不会受影响
• 不会出现之前的流切换冲突问题：全局cout只做一次缓冲区替换，后续的路由逻辑是单线程内的分支判断，不会被其他线程干扰
• 程序退出时，ofstream对象会自动析构刷盘，不需要手动处理文件关闭逻辑

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