Re: What is the problem with writing singleton in multithreaded enviroment
Timo Geusch wrote:
James Kanze wrote:
[... concerning the initialization of a local static in a
function called by more than one thread...]
Given 1) and 2), it's implementation defined. G++ defines it,
and there's no problem. Most other compilers don't, and in the
absence of a concrete guarantee, you have to assume that there
may be a race condition (and actually is if more than one thread
calls the function before construction is completed in many
implementations).
Thanks for writing what I was trying to say - I've certainly been
bitten by compilers that don't offer the guarantee and am a tad too
familiar with it for my own good.
IMHO, it's probably a good rule today to suppose that it isn't
safe, and that you, the user, are responsible for any
synchronization. Of the compilers I use (Sun CC, g++ and VC++),
only g++ makes any effort with regards to synchronization, and
the code they generate for it is broken (and can hang because of
a priority inversion in certain cases) on a Sparc, so you'd
generally compile with the option to turn it off too.
[...]
Double checked locking doesn't really apply in your case anyway but
would normally look like this C++-like pseudo code:
foo* bar::get_foo_instance()
{
if (!foo_instance) {
lock.aquire();
if (!foo_instance) [
foo_instance = new foo;
}
lock.release();
}
}
Except, of course, that this code doesn't work.
That's why it's called pseudo code :).
I wasn't sure whether you were suggesting it, or simply saying
that this is what is generally meant by DCL. I suspected the
latter, but I do feel it better to indicate to the original
poster that DCL doesn't work, at least not without some special
assembler (or a compiler extension, but I don't know off hand of
any compiler which offers one).
Note that both this and the original version with the local
static work fine IF you can guarantee that the first call to the
function (which triggers construction) occurs before
multithreading starts. (Note, however, that this guarantee is
something I have established pragmatically, based on what I know
about how compilers handle local statics. The standard is, of
course, silent about it, and I've yet to see a compiler which
actually gives an explicit guarantee.) I often do something
like:
foo* foo_instance = bar::get_foo_instance() ;
for example, to ensure that the function is called once during
the initialization of static objects---on every compiler I know
of, this occurs before entering main, and I never start
threading until after entering main.
Another solution that I've occasionally used is based on the
fact that if the singleton object is not const, client code will
probably need a lock anyway to access it. So I merge the two,
acquiring the lock before the first test of the pointer, and
returning a boost::shared_ptr to the object, with a "destructor"
which frees the lock (rather that deleting the object).
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientie objet/
Beratung in objektorientierter Datenverarbeitung
9 place Simard, 78210 St.-Cyr-l'Icole, France, +33 (0)1 30 23 00 34
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]