在多个线程中使用std::cout

using std::cout in multiple threads

本文关键字：std cout 线程      更新时间：2023-10-16

我写了一个简单的程序来测试c++11中的Thread，但std::cout并没有像我预期的那样工作。

class Printer
{
public:
    void exec()
    {
        mutex m;
        m.lock();
        cout<<"Hello  "<<this_thread::get_id()<<endl;
        chrono::milliseconds duration( 100 );
        this_thread::sleep_for( duration );
        m.unlock();
    }
};
int main()
{
    Printer printer;
    thread firstThread([&printer](){
        while(1)
            printer.exec();
    });
    thread secondThread([&printer](){
        while(1)
            printer.exec();
    });
    firstThread.join();
    secondThread.join();     
}

一些结果：

Hello 11376
Hello 16076
Hello 16076
Hello Hello 11376
16076
Hello 11376
,....

我使用互斥锁来锁定线程，所以我不明白为什么两个线程同时执行std::cout。这让我很困惑。有人能解释发生了什么吗！？！

线程使用不同的mutex实例，因为mutex是exec()函数中的局部变量，所以锁定mutex毫无意义，因为每个线程都将锁定自己的mutex，导致线程之间没有同步。线程必须使用相同的mutex实例才能实现同步。

要更正已发布的代码，请将mutex作为成员变量。但是，如果创建了另一个Printer对象，那么使用不同Printer实例的线程之间就不会同步。在这种情况下，mutex需要是static成员变量以确保同步：

class Printer
{
public:
    //...
private:
    static std::mutex mtx_;
};
std::mutex Printer::mtx_;

为了确保mutex始终被释放，无论函数是正常退出还是通过异常退出，请使用std:lock_guard:

std::lock_guard<std::mutex> lock(m); // 'm' locked, and will be
                                     // unlocked when 'lock' is destroyed.
std::cout<< "Hello  " << std::this_thread::get_id() << std::endl;
std::chrono::milliseconds duration( 100 );
std::this_thread::sleep_for( duration );

接受的答案是正确的。然而，将关注点分开是很好的：

  1. 您需要一种以线程安全的方式打印到std::cout的方法
  2. 您需要创建对象/函数/函数来在线程中运行并启动它们

下面是我使用的一个实用程序，它只专注于收集std::cout的参数，并在static std::mutex:下将它们流式传输出去

#include <iostream>
#include <mutex>
std::ostream&
print_one(std::ostream& os)
{
    return os;
}
template <class A0, class ...Args>
std::ostream&
print_one(std::ostream& os, const A0& a0, const Args& ...args)
{
    os << a0;
    return print_one(os, args...);
}
template <class ...Args>
std::ostream&
print(std::ostream& os, const Args& ...args)
{
    return print_one(os, args...);
}
std::mutex&
get_cout_mutex()
{
    static std::mutex m;
    return m;
}
template <class ...Args>
std::ostream&
print(const Args& ...args)
{
    std::lock_guard<std::mutex> _(get_cout_mutex());
    return print(std::cout, args...);
}

此代码可以重用于std::cout以外的流，但以上代码专门针对std::cout。有了这个，你的Printer::exec()现在可以显著简化：

void exec()
{
    print("Hello ", std::this_thread::get_id(), 'n');
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

现在，您的Printer不仅可以以线程安全的方式使用cout，而且已经简化（例如，对于cout不需要维护自己的mutex），而且您的所有其他类型和函数也可以使用cout，并且可以安全地进行互操作。print函数本身现在维护mutex，并且该事实被封装在print的所有客户端之外。

我将分享Nicolás在这个问题中给出的技巧，我发现它比Howard Hinnant实现更优雅。其想法是创建一个临时的ostrinstream对象，并将保护代码放在析构函数上。

/** Thread safe cout class
  * Exemple of use:
  *    PrintThread{} << "Hello world!" << std::endl;
  */
class PrintThread: public std::ostringstream
{
public:
    PrintThread() = default;
    ~PrintThread()
    {
        std::lock_guard<std::mutex> guard(_mutexPrint);
        std::cout << this->str();
    }
private:
    static std::mutex _mutexPrint;
};
std::mutex PrintThread::_mutexPrint{};

然后，您可以从任何线程将其用作常规std::cout：

PrintThread{} << "val = " << 33 << std::endl;

该对象以常规std::ostringstream的形式收集数据。一旦达到昏迷状态，物体就会被摧毁，并刷新所有收集到的信息。

您可以考虑全局std::mutex cout_mutex;（在命名空间中的某个位置），它用于保护std::cout输出。请确保使用std::lock<std::mutex>（这样您就不会忘记解锁互斥锁并确保异常安全）。

相关文章：