std::cout 线程安全格式化和 io 操作答案

【问题标题】：std::cout thread safe formatting and io manipulationstd::cout 线程安全格式化和 io 操作
【发布时间】：2020-08-12 12:38:57
【问题描述】：

假设您有两个线程。第一个线程尝试使用std::dec 将整数打印为十进制：

std::cout << std::dec << 123 << std::endl;

第二个线程尝试使用std::hex 将整数打印为十六进制：

std::cout << std::hex << 0x321 << std::endl;

是否保证 123 将打印为十进制，而 0x321 将打印为十六进制？如果不是，我该如何在多线程环境中正确格式化std::cout？

C++20 有std::osyncstream。但是在 C++20 之前我们可以使用什么？

【问题讨论】：

std::mutex
这能回答你的问题吗？ How to easily make std::cout thread-safe?
@bolov，如果使用有自己线程的第三方库怎么办？
如果没有一个互斥锁来包装对std::cout 的整个访问权限，或者一个临时缓冲区，然后只保护互斥锁的最终写入，就没有解决方案。如果您担心嵌入式中的临时缓冲区性能，请提供一个 custom allocator 到 std::stringstream，它会预先分配最多 n 字节内联（在嵌入式缓冲区中），并且只会超过堆中的分配。
@anton_rh：如果我没看错的话，osyncstream 本身不会将cout 更改为具有互斥属性。它是一种可以像同步流一样工作的类型。所以它不能解决你提出的第 3 方问题。

标签： c++ multithreading iostream

【解决方案1】：

从一开始，std::cout 就没有这个选项。

如果您只是想使用不同的对象，一种简单的方法就是对所需的每个“复合”使用 stringstream，例如：

std::cout << (std::ostringstream{} << std::hex << 0x321 << std::endl).str();

或者，您可以创建自己的流类，在销毁时将所有内容转发到 std::cout（例如，您可以将 std::ostringstream 作为成员或继承它）：

~MyStringStream(){
  std::cout << str();
}

我不建议在实际的 std::cout 上更改这一事实，因为其他人不会期望 std::cout 以这种或那种不同的方式表现。然而话虽如此，我认为重定向是可能的，所以我创造了一种方式来展示这一点（有点像黑客：我认为所有做这样的事情都是黑客）以及如何使这成为可能。请注意，这根本不是一个完整的解决方案，它只是展示了如何让std::cout 通过你自己的流类，然后需要“正确”实现/覆盖，使线程安全，然后添加必要的同步，或者您计划获得额外的级别等。还请注意，我还没有考虑过这会如何干扰std::cout tie'ed 流（例如std::in、std::err），但我猜它是没什么大不了的。

Try it yourself on godbolt

#include <utility>
#include <string>
#include <iostream>
#include <sstream>


std::stringstream new_out;

class SyncedStreamBuf : public std::stringbuf {
public:
  SyncedStreamBuf(){}
  

  virtual int sync() override {
    new_out << "From override: " << str();
    str("");//empty buffer
    return 0;//success
  }
};

class SyncedStream : public std::ostream {
public:
  SyncedStream() : std::ostream(&syncedStreamBuf_){
  }

private:
  SyncedStreamBuf syncedStreamBuf_;
};

SyncedStream my_stream;

int main()
{
    std::streambuf* cout_buff = std::cout.rdbuf(); // save pointer to std::cout buffer
 
    std::cout.rdbuf(my_stream.rdbuf());//redirect cout to our own 'stuff'
    
    static_cast<std::ostream&>(new_out).rdbuf(cout_buff);//put cout's buffer into a new out stream
    
    
    new_out << "test: new_out now prints to stdout\n";
    std::cout << "some message\n";//<--now goes through our overridden class
    std::cout.flush();

    std::cout << "you will see this message - didn't flush\n";
}

输出：

test: new_out now prints to stdout

From override: some message

【讨论】：

单独缓冲是不够的。仍然需要围绕对std::cout 的访问的静态范围互斥锁，以防止在逐个字符的基础上进行交错。此外，由于中间转换为字符串，您的第一个示例没有刷新，失去了 std::endl 的常见副作用。
@Ext3h 很棒的评论，谢谢。我不确定您是否说这种方法可能或不可能？我仍然认为重定向到自己的缓冲区应该是可能的。

【解决方案2】：

使用函数打印输出。仅从此功能打印输出。在这个函数中使用互斥锁。

OutputFunction(int form, const int& value)
{
    std::lock_guard<std::mutex> m_OutputMutex;
    if(form == 0)// 0 means dec
    {
        std::cout << std::dec << value << std::endl;
    }
    elseif(form ==1)
    {
        std::cout << std::hex << value << std::endl;
    }
}

【讨论】：