使用互斥体的线程安全 std::cout

Question

我尝试使一些线程安全 std::cout ，对我来说最好的解决方案如下所示：

void print(std::ostream &out) 
{
    pthread_mutex_lock(&m_mutex);
    std::cout << out;
    pthread_mutex_unlock(&m_mutex);
}

我想使用是这样的：

print("hello" << std::endl);

但不幸的是我收到编译器错误：

test.cpp:38: error: no match for ‘operator<<’ (operand types are ‘std::ostream’ {aka ‘std::basic_ostream<char>’} and ‘std::ostream’ {aka ‘std::basic_ostream<char>’})
test.cpp: In function ‘void print(std::ostream&)’:
test.cpp:38:15: error: no match for ‘operator<<’ (operand types are ‘std::ostream’ {aka ‘std::basic_ostream<char>’} and ‘std::ostream’ {aka ‘std::basic_ostream<char>’})
   

对我来说这是消息绝对不可读。

我在这里做错了什么？

Answer 1

这里有几个问题。

首先，std::cout << out; 是错误的，因为这些操作数的 operator<< 没有匹配的重载（out 是一个 std::ostream&代码>此处）。这基本上就是所谓的“不可读”错误消息所说的内容。

这同样适用于 "hello" << std::endl 出于同样的原因。

此外， std::endl 是一个函数 不仅仅是一个模板化函数。如果您想将其作为参数传递，则必须指定所需的重载，在本例中为 std::endl>。

您可以通过以下方式简化符号：

auto endl = std::endl<char, std::char_traits<char>>;

这样，您可以传递先前定义的 endl 函数。

---

为了解决您的问题，我认为一个好的解决方案是将过程分为两个步骤：

• 将数据累积到流中（我将在此处使用 std::stringstream ）
• 打印累积的数据。

为此，您可以将所有机制隐藏在辅助类中，我们将其称为 Printer。

为了使其像您希望的那样灵活，我们可以使用可变参数模板。
然后语法将从 "hello" <<值<< ... 到 “你好”，值，...。

综上所述，我们可以将 Printer 类的定义为：

class Printer final
{
    private:
        std::stringstream s;

        template <typename T>
        void accumulate(T && t)
        {
            s << std::forward<T>(t);
        }

        template <typename T, typename ... Ts>
        void accumulate(T && t, Ts && ... ts)
        {
            s << std::forward<T>(t);
            accumulate(std::forward<Ts>(ts)...);
        }

    public:
        template <typename ... Ts>
        void print(Ts && ... ts)
        {
            //lock

            accumulate(std::forward<Ts>(ts)...);
            std::cout << s.view(); // Use s.str() instead if before C++20

            s.str(std::string());
            s.clear();

            //unlock
        }
};

注意： 如果您之前是 c++20，您可以替换s.view();< /代码> 与s.str();。

然后您可以按如下方式使用它：

int main()
{
    auto endl = std::endl<char, std::char_traits<char>>;

    std::string val("Bye !");

    Printer p;
    p.print("Hello", " !", '\n', val, endl);

    return 0;
}

输出：

你好！
再见！

这里是实例

---

注意： 这样做会更安全使用 std::scoped_lock （或 std::lock_guard 如果在 c++17) 而不是传统的锁定/解锁机制，因为它利用 RAII 来确保互斥体在超出范围时被释放（例如，在释放之前抛出异常的情况）。

注2：如果你不想使用Printer实例，你可以将里面的所有内容声明为static，这样你就可以直接使用打印机::print(...);。

Answer 2

使用类似于 and 的函数

print("hello" );

如果您想在要输出的函数中

std::cout << "hello" << std::endl;

，那么您需要使用字符串文字“hello”作为函数参数。

例如

std::ostream & print( const std::string &s, std::ostream &out = std::cout ) 
{
    pthread_mutex_lock(&m_mutex);
    out << s << std::endl;
    pthread_mutex_unlock(&m_mutex);

    return out;
}

//...

print("hello" );

，或者可以将参数声明为类型 std::string_view。例如

std::ostream & print( std::string_view s, std::ostream &out = std::cout ) 
{
    pthread_mutex_lock(&m_mutex);
    out << s << std::endl;
    pthread_mutex_unlock(&m_mutex);

    return out;
}

Answer 3

好吧，一个完全适合我的解决方案是使用上面建议的缓冲输出。

std::stringstream stream;
stream << "value " << some_string << " is " << some_value << std::endl;
std::cout << stream.str();

我已经用 10 个线程测试了这个结构，这些线程经常打印到控制台。

Answer 4

您可以使用MacCro进行。

#define PRINT(out, message) do { scoped_lock(); out << message << std::endl; } while(false)

然后，当在代码中替换时：

PRINT("hello !");
// actually is equivalent to
{
  scoped_lock();
  out << "hello !" << std::endl;
}

PRINT("a = " << a << ", b = " << b << std::endl
   << "total = " << compute_total_value());
// actually is equavalent to
{
  scoped_lock();
  out << "a = " << a << ", b = " << b << std::endl
      << "total = " << compute_total_value() << std::endl;
}

for(int i = 0; i < 10; ++i)
  PRINT("i = " << i);
// actually is equavalent to
for(int i = 0; i < 10; ++i)
{
  scoped_lock();
  out << "i = " << i << std::endl;
}

注意：如果您不想在消息后添加自动端口，则可以通过 std :: flush 替换它。

注意：在这种代码中，您需要使用示波器锁定而不是锁定/解锁说明，即使流动使用或通过<<<代码>消息。

注意： do {} whe（false）在MacCro中使用，因为它是编译器可以将其视为唯一的范围。当在没有牙套的循环中使用时，它会避免隐藏的错误。