C++ 在多线程中使用std:：cout

我用c++11编写了一个测试线程的简单程序，但是

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();     
}

我使用互斥锁来锁定线程，所以我无法理解为什么两个线程同时执行

std:：cout

。 我很奇怪。有人能解释发生了什么事吗

线程使用不同的

mutex

实例，因为

mutex

是

exec（）

函数中的一个局部变量，因此锁定

mutex

毫无意义，因为每个线程都将锁定自己的

mutex

，导致线程之间不同步。线程必须使用相同的

mutex

实例来实现同步

要更正已发布代码中的错误，请将

互斥体

设为成员变量。但是，如果创建了另一个

打印机

对象，则使用不同

打印机

实例的线程之间不会同步。在这种情况下，

mutex

需要是一个

静态

成员变量，以确保同步：

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

std::mutex Printer::mtx_;

---

要确保始终释放

互斥

，无论函数是否正常退出或通过异常退出，请使用：

std:：锁(m)/'我被锁上了，我会的
//当“锁”被破坏时解锁。
STD：：CUT
您可以考虑全局<代码> STD:：互斥CutuMutX；<代码>（在您的名称空间中的某个位置），用于保护
std:：cout
输出。确保您使用了
std:：lock
（这样您就不会忘记解锁互斥锁并确保异常安全）。
接受的答案是正确的。但是，最好将关注点分开：

您需要一种以线程安全方式打印到
std:：cout
的方法
您需要创建对象/functor/函数以在线程中运行并启动它们
下面是我使用的一个实用程序，它只集中于收集
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...);
}

现在，不仅您的
打印机将以线程安全的方式使用
cout
，而且已经简化（例如，不需要为
cout
维护自己的
mutex
），而且您的所有其他类型和功能也可以使用
cout
，并且可以安全地进行互操作。
print
函数本身现在维护了
mutex
，这一事实被封装在所有
print
的客户端之外。
我正在分享Nicolás的技巧，我发现它比Howard Hinnant实现更优雅。其思想是创建一个临时ostringstream对象，并将保护代码放在析构函数上

/** 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:：ostringstream
的形式收集数据。一旦到达coma，对象将被销毁并刷新所有收集到的信息。
修复方法是使用
静态
存储持续时间声明
互斥
。。。或者是。@Casey，或者是一个成员变量，因为线程使用的是相同的
打印机
实例。@hjmd在这种情况下，我希望
静态
与
std:：cout
的范围相对应。这样，当一些维护程序员在其他功能中创建另一个
打印机时，它将继续工作。在这种情况下，unique_lock会更好，因为它允许在向cout发送数据之后进入睡眠之前解锁（在睡眠期间保持互斥锁没有好处）.一旦您实施了答案中提供的解决方案，您还应该使用
lock\u guard
s，而不是手动锁定/解锁呼叫。不要费心冲洗（例如，使用
endl
）；只需使用“\n”。打印是一个模板函数。我想你可能会有不止一个互斥体。@JanChristophUhde:观察得很好！只花了3年时间就有人注意到了！：-）固定的。谢谢。下面是一个测试用例，略述一下这个答案。在PrintThread的示例用法中，'std:：endl'操纵器可以（应该？）替换为'\n'，因为您正在向ostringstream dervied对象写入数据。请注意，当调用~PrintThread（）析构函数时，调用基类std:：ostringstream析构函数时会刷新“this”对象，因此无需通过std:：endl“手动”刷新PrintThread对象。在~PrintThread（）析构函数方法中，在将“this->str（）”写入cout之后刷新cout流可能是值得的——即std:：cout str（）
#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...);
}

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

/** 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{};

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