Re: Double-checked locking: is this alternative OK?
JohnQ wrote:
SomeObject* instance() // flawed way
{
static SomeObject* instance = NULL;
LockThing(); // locking even when not required
if(instance == NULL) // instance may still be NULL when another
thread checks
instance = new SomeObject();
UnlockThing(); // oh dang, more unnecessary function calls after
first pass
return instance;
}
Could you explain why you don't do it this way:
if (instance == NULL) {
LockThing();
instance = new SomeObject();
UnlockThing();
}
return instance;
? That should avoid the unnecessary locking you mention, no?
SomeObject* instance() // OK?
{
static bool been_there_done_that = LockThing();
static volatile instance = new SomeObject(); // no problemo (on X86
hardware)
static bool been_there_done_that_B = UnlockThing();
return instance; // fast is nice! No overhead after first pass
through function
}
John
The problem with having to double-check is not solved by your static
initialisation, however. The language at this point makes no attempt
to resolve the problem of calling the function "for the first time"
from two different threads. And AIUI the sequence of events in that
case can be
Thread 1 Thread 2
LockThing() - succeeds
LockThing() - fails, waits
new SomeObject() . // waiting
UnlockThing() . // waiting
return instance
new SomeObject() // overrides instance
UnlockThing()
return instance // different instance
The Committee is working on thread support, however. Static
initialisations would have to be resolved before the thread support
can be claimed, that's for sure.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask