Re: Thread save access to cout?
On Feb 26, 7:09 am, Henryk <henryk.muel...@gmx.de> wrote:
Ok, my question is a little system-related. C++ does not know anything
about threads, I know. But where else to ask?
Under linux with libstdc++.so.6 is writing to cout thread save or do I
need to make it thread safe by some kind of wrapper?
The impact to existing code should be minimal (at best a simple search
& replace).
Would something like this do:
inline std::ostream &Wrapper::cout() {
Lock lock(mutex);
return std::cout;
}
And then use it like this
Wrapper::cout() << "print something" << "print more" << std::endl;
How long does the scoped lock protect the access to std::cout? The
mutex is released within lock's destructor, which is called after the
return statement.
I tested it in an VM environment and it worked as far as I visually
checked the output. But does it work for sure?
Thanks for any insights!
Henryk
What we do is to separate the message builder from the class/function
that does the actual output. This way, the class that does the output
is trivial - it only outputs a string inside a function that is
protected by a lock.
Here's some psuedo code that implements a message builder. The key
point is that it implements the stream operator, and it's destructor
does the actual output by using some other mechanism to produce thread
safe output. If you don't like the operation in the destructor, then
just put it inside a member function.
// message builder
class LogMessage
{
public:
// default construct
LogMessage()
{}
// constructor taking a context
LogMessage(const char * context)
{
m_ss << context << ": ";
}
// constructor taking a context
LogMessage(const std::string & s)
{
m_ss << context << ": ";
}
// destructor - output the message to logger
~LogMessage()
{
logIt(m_ss.str());
}
// stream operator
template <class T>
LogMessage & operator<<(const T & t)
{
m_ss << t;
return *this;
}
private:
m_ostringstream m_ss;
};
//
//Use it like this somewhere else:
//
// build a message, it gets logged when the class destructs at the
semicolon
LogMessage("demo") << "this is a log message: " << 10;
// In some other file - the actual class (singleton) or function that
// does thread safe logging
// thread safe access to log stream
LogIt(const std::string & s)
{
// do lock here
std::cout << s << std::endl;
}
HTH