将std::cout重定向到std::ofstream后是否仍具备线程安全性？

背景与实现方案 #

我打算将写入std::cout的内容捕获并重定向到文本文件，计划采用以下方案：

std::ofstream out("out.txt");
std::cout.rdbuf(out.rdbuf()); // 将std::cout重定向到out.txt

std::cout << "blabla" << std::endl;  // 输出到文件out.txt

疑问 #

根据cppreference文档，多线程同时写入std::cout是安全的，但可能出现文本交错。我想知道：将std::cout重定向到std::ofstream后，在多线程环境下是否仍具备线程安全性？ 我知道std::ofstream本身并非线程安全。

测试实现与现象 #

我自行实现了一个注入std::cout的std::streambuf，用5个线程写入std::cout做测试：

#include <iostream>
#include <thread>
#include <atomic>

using namespace std;

class StreamToLogRedirector : public std::streambuf
{
public:
    StreamToLogRedirector() : counter(0) {}

    std::streamsize xsputn(char_type const* s, std::streamsize count) override
    {
        counter++;
        if (counter > 1)
        {
            std::cerr << "Counter " << counter << std::endl;
        }
        counter--;
        return count;
    }

    int overflow(int c) override
    {
        counter++;
        if (counter > 1)
        {
            std::cerr << "Counter " << counter << std::endl;
        }
        counter--;
        return c;
    }

private:
    std::atomic<int> counter;
};

int main()
{
    StreamToLogRedirector redirector;
    std::cout.rdbuf(&redirector);

    auto a = std::thread([](){ while (true) std::cout << "Write from A\n"; });
    auto b = std::thread([](){ while (true) std::cout << "Write from B\n"; });
    auto c = std::thread([](){ while (true) std::cout << "Write from C\n"; });
    auto d = std::thread([](){ while (true) std::cout << "Write from D\n"; });
    auto e = std::thread([](){ while (true) std::cout << "Write from E\n"; });
    
    a.join();
    b.join();
    c.join();
    d.join();
    e.join();

    return 0;
}

测试中发现计数器达到5，说明StreamToLogRedirector的成员函数被并行调用。

我的结论 #

线程安全性并非由std::ostream的std::cout对象层面处理，而是由底层的std::streambuf负责。若std::ofstream本身非线程安全，那么将std::cout重定向到它后，std::cout的使用也不再具备线程安全性。

请问我的结论是否正确，还是我遗漏了某些要点？

解答 #

你的结论完全正确，核心要点如下：

1. 标准库对std::cout的线程安全保证仅针对默认流缓冲：cppreference提到的多线程写入std::cout安全，是因为默认关联的控制台流缓冲实现了同步机制，能避免数据竞争（但不保证输出不交错）。
2. 流缓冲是线程安全的核心载体：std::ostream的operator<<等操作本身不做线程同步，所有安全保障都依赖底层std::streambuf的实现。替换成std::ofstream的缓冲后，由于该缓冲无内置同步机制，多线程写入会触发数据竞争，导致未定义行为。
3. 你的测试直接验证了这一点：自定义缓冲中计数器达到5，证明多个线程同时进入写入函数，原std::cout的线程安全保障在替换缓冲后已失效。

如果需要在多线程环境下安全重定向std::cout到文件，需自行添加同步机制：比如在自定义streambuf中用std::mutex保护所有写入函数，或在每个线程的std::cout操作外层加锁。

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