Re: implementation of "Double-Checked Locking" Pattern in C++

Hi All,

The Double-Checked Locking Pattern is a common approach to efficient
lazy initialization. Unfortunately, it's not reliable in C++ in
threaded systems, it can fail for different reasons in uniprocessor
and multiprocessor environments, and there's no portable way to make
it reliable.

Is there any way for implementing the "Double Check Lock Pattern" 100%
Thread Safe???

Sample C++ code example code that implements Double-Checked Locking:

Singleton* Singleton::Instance() {

if (0 == pInstance)
{

Guard lock(m_mutex);

if (0 == pInstance)

pInstance = new Singleton;

}

return pInstance;

}

The crux of the problem lies in the way C++ objects are created. They
are not always created in the same manner.

With "pInstance = new Singleton", three things happen:

1. Memory is allocated to hold a Singleton object.

2. The Singleton is constructed inside the allocated memory.

3. The address of the allocated memory is assigned to pInstance.

But the compiler is not constrained to perform these steps in this
order! This creates a problem when step two and three are swapped:

1. Memory is allocated to hold a Singleton object.

2. The address of the allocated (un?initialized) memory is assigned to
pInstance.

3. The Singleton is constructed inside the allocated memory.

What will happen when thread A is suspended just after it finishes
step two and thread B enters the ?Instance()? function?

It will detect that pInstance is not 0 anymore and may exit the
function, returning the address to a section of memory that has not
been initialized. Thus the code that was calling the Instance function
could dereference a Singleton object that has not been constructed
yet! Chaos ?