我在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
。
它接缝非常适合我。任何人都可以解释发生了什么!?!
答案 0 :(得分:30)
线程正在使用不同的 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 :(得分:15)
接受的答案是正确的。然而,将问题分开是很好的:
std::cout
的方法。这是我使用的一个实用程序,它专注于收集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
,而且已经过简化(例如,不需要为mutex
维护自己的cout
),但所有其他类型和功能也可以使用cout
并且所有人都可以安全地互操作。 print
函数本身现在维护mutex
,并且该事实被封装在远离所有print
客户端的位置。
答案 2 :(得分:4)
我正在分享this question中给出的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
收集数据。一旦达到昏迷,对象就会被销毁并清除所有收集到的信息。
答案 3 :(得分:1)
您可以考虑全局std::mutex cout_mutex;
(名称空间中的某个位置),用于保护std::cout
输出。确保使用std::lock<std::mutex>
(这样您就不会忘记解锁互斥锁并保证安全性。)