C++ in Theory: Why the Double Check Lock Pattern Isn`t 100% Thread Safe - The Original Problem
(Page 2 of 6 )
We have been implementing the Singleton Pattern [Gamma] in C++ to aid us in our quest to make sure we have only one unique instance of an implementation available during runtime. The Singleton is accessed exclusively through the ‘Instance()’ member function, which takes care of object creation and destruction. It also uses lazy initialization, which means that the Singleton is not created and stored until it is first accessed.
The benefit of lazy initialization is that the Singleton won’t be created until it is needed, and if it isn’t needed, memory and construction time won’t be wasted on it. It does introduce a major problem when we want to use our Singleton in a multithreaded environment.
Let us ignore policy based class design and everything else described in the previous articles, and look at the Instance function as described in "Design Patterns" [Gamma].
Singleton* Singleton::Instance () {
if (0 == pInstance)
pInstance = new Singleton;
return pInstance;
}
The Singleton should guarantee us only one instance of the implementation at runtime, but le'ts see what might happen when this code is run in a multithreaded environment.
If thread A is suspended after the if statement and before the creation of the Singleton, thread B might come in (pInstance is still 0) and create a Singleton. As soon as thread A resumes execution it creates a second Singleton. That is not what we had in mind when implementing this pattern!
Mutexes are used to synchronize thread access to sections of code. When a mutex is placed at the start of an Instance function’s body, we are sure that only one Singleton is ever created:
Singleton* Singleton::Instance() {
Guard lock(m_mutex);
if (0 == pInstance)
pInstance = new Singleton;
return pInstance;
}
However it is very time consuming to get a lock on a mutex, and this solution may introduce a performance hit when you access the Singleton a lot through the ‘Instance()’ function. It sure doesn’t make sense to have to pay this price when you need it only once (i.e. when you have to create the Singleton object). This is where the Double Checked Locking Pattern comes in.
Next: The Double Checked Locking Pattern >>
More C++ Articles
More By J. Nakamura
/ 12 
