Re: Confused about a thread-safe singleton example.
On Dec 3, 4:53 am, James Kanze <james.ka...@gmail.com> wrote:
On Dec 3, 1:25 am, "jason.cipri...@gmail.com"
<jason.cipri...@gmail.com> wrote:
I have a C++-specific question about thread-safe singleton instances.
There's a trivial example here:
http://www.bombaydigital.com/arenared/2005/10/25/1
That goes like this, very simple and straightforward:
static Mutex mutex;
static TheClass *instance;
static TheClass * getInstance () {
MutexLocker lock(mutex);
if (!instance)
instance = new TheClass();
return instance;
}
The example then goes on to talk about how double-check
locking is broken, etc. My question is pretty much this: Is
C++ static initialization thread-safe?
No.
It's actually very hard to answer concretely here. Objects with
static lifetime in class or namespace scope are constructed
before main is entered, so if threads aren't started until then,
you're OK. Except that if getInstance is called before then,
you may have an order of initialization problem. And the
guarantee of construction before main is entered doesn't apply
to dynamically linked objects (which aren't addressed by the
standard, but then, neither is multi-threading).
Thanks! Fortunately in my case things are simple, I don't have to deal
with dynamically linked objects, and I can guarantee that no threads
are started before main().
I have another question, on the subject of static initialization order
in general, not thread safety. Is it guaranteed that statics in a
given translation unit will be initialized before the first time a
function in that translation unit is called? E.g. if I have this:
static TheClass *ourInstance = new TheClass;
TheClass & TheClass::instance () {
return *ourInstance;
}
Even I call TheClass::instance() during static initialization of
another object that was initialized first, will simply calling that
function guarantee that ourInstance will be initialized in time?
My usual solution here is something like:
namespace {
TheClass* ourInstance = &TheClass::instance() ;
}
TheClass&
TheClass::instance()
{
if ( ourInstance == NULL ) {
ourInstance = new TheClass ;
// or
static TheClass theOneAndOnly ;
ourInstance = &theOneAndOnly ;
}
return *ourInstance ;
}
The initializer for the static variable ensures that
TheClass::instance is called at least once before main is
entered, and once you've returned from a call to
TheClass::instance(), the function is thread safe without locks.
If not, then how does the above example safely use "mutex"? If
so, then what is wrong with this:
static TheClass instance; // not a pointer
static TheClass * getInstance () {
return &instance; // it's correctly initialized?
}
The reason I ask is I almost never see it done like that, I
always see blog entries and articles that say the same thing
"store instance in a pointer, use a mutex to protect, and p.s.
double-checked locking is broken". It seems like doing it
lock-free is made out to be a hard problem, so *if* having a
static instance works (but I don't know if it does, that's my
question), then why doesn't anybody ever suggest it?
Because it's open to order of initialization issues.
I see, that does explain it. I guess it's only useful in limited
situations.
Thanks again,
Jason