Re: Stream thread-safety
On Feb 12, 7:35 pm, Yang Zhang <yanghates...@gmail.com> wrote:
I know that std streams are not thread-safe (i.e., output can
end up becoming interleaved), but do they share mutable state?
(At least in libstdc++ 4.2 on Linux kernel 2.6.x?)
That's very implementation defined. They certainly depend at
least a little on shared mutable state, since they use dynamic
memory.
It shouldn't matter, however. Unless there's an error in the
implementation, if the implementation is given as being usable
in a multithreaded environment (which is what thread-safe
means), it's not your problem. You only need to synchronize if
several threads are accessing the same stream.
I just spent a long time tracking down a bug in my program where,
given enough threads, eventually all cout<<int would print in hex
rather than dec, even though I never used stream formatters. couts in
this program are called from multiple threads, and some couts around
the middle of my program ended up interleaved - couts before it are
fine, and later ones end up in hex. After removing the contentious
couts in the middle, the problem went away - no more hex.
Obviously, all accesses to cout must be synchronized externally
if cout is used by more than one thread. Otherwise, it's your
program which isn't thread safe, not cout. And just as
obviously, it is the responsibility of whoever modifies a
formatting flag to restore it after they've finished---and
before they free up any synchronization.
Could this have been an effect of using the streams from
multiple threads?
Not if the threads are using the object correctly. If each
thread acts as if it were the only thread using the resource,
however, anything could happen.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34