18

我编写了一个简单的程序来测试 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();     
}

一些结果:

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

我使用互斥锁来锁定线程,所以我不明白为什么两个线程同时执行std::cout。它对我来说很奇怪。任何人都可以解释发生了什么!?!

4

4 回答 4

33

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

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

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

std::mutex Printer::mtx_;

为了确保 amutex总是被释放,无论函数是正常退出还是通过异常退出,请使用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 );
于 2013-08-16T15:47:37.450 回答
18

接受的答案是正确的。但是,将关注点分开是很好的:

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

这是我使用的一个实用程序,它只专注于收集参数std::cout并将它们流式传输到 a 下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,但上面专门针对 target 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,而且已经简化(例如不需要维护自己的mutexfor cout),而且您的所有其他类型和函数也可以cout安全地使用并一起进行互操作。该print函数本身现在维护mutex,并且该事实被封装在远离所有print客户端的地方。

于 2013-08-16T20:40:46.930 回答
7

我正在分享 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::cout

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

该对象定期收集数据std::ostringstream。一旦达到昏迷状态,对象就会被销毁并刷新所有收集到的信息。

于 2017-01-11T23:58:45.077 回答
1

你可以考虑一个全局的std::mutex cout_mutex;(在你的命名空间中的某个地方),它用于保护std::cout输出。确保你使用std::lock<std::mutex>(这样你就不会忘记解锁互斥锁和异常安全)。

于 2013-08-16T17:44:21.307 回答