Re: Thread save access to cout?

From:

Michael Doubez <michael.doubez@free.fr>

Newsgroups:

comp.lang.c++

Date:

Fri, 26 Feb 2010 04:45:20 -0800 (PST)

Message-ID:

<2e7bd21f-1746-4a06-b70d-98a444638986@q16g2000yqq.googlegroups.com>

On 26 f=E9v, 13:09, 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?

It doesn't.

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?

The stream is locked only within the function, which is useless.

With a lock, the solution should be
{
  Lock lock_cout;
  std::cout<< ...;
  std::cout<< ...;
} // unlock cout

With a wrapper: instantiate a temporary that stays lock and redefine
operato<< for it:
class locked_cout
{
  public:
    locked_cout():lock(locked_cout::mutex)
    { /* NOP */ }
  private:
    // Lock
    Lock lock;
    // program wide mutex
    static mutex _mutex;
};

template<class T>
const locked_cout& operator<<(const locked_cout& lcout, const T& t)
{
  std::cout<<t;
  return lcout;
}

const locked_cout& operator<<(const locked_cout& lcout, std::ios_base
(*manip)( std::ios_base& ) )
{
  std::cout<<manip;
  return lcout;
}

const locked_cout& operator<<(const locked_cout& lcout, std::ostream&
(*manip)( std::ostream& ) )
{
  std::cout<<manip;
  return lcout;
}

And you can do:
locked_cout()<< ... ;
or
{
const locked_cout lcout;
lcout<<...;
lcout<<...:
}

Credit: IIRC I have first seen this solution from James Kanze.

--
Michael