Comments on: Optimizing Singletons With Double Checks

by: Mahmoud Abdelkader

Fri, 10 Oct 2008 17:02:03 +0000

As someone mentioned earlier, this becomes problematic as you’re running into the anti-pattern of double checked locking. This idiom has been tried again and again, only to realize that it does not work.

I know you can get around it by using ‘volatile’ in Java and possibly the same thing in C++.

by: Bill Robertson

Fri, 10 Oct 2008 00:01:24 +0000

That is one of the things that led to the revisions in the Java memory model a few years ago. The new C++ standard has the notion to address this sort of thing.

Here’s what a quick google search turns up on the problem (in C++)

http://www.devarticles.com/c/a/Cplusplus/C-plus-in-Theory-Why-the-Double-Check-Lock-Pattern-Isnt-100-ThreadSafe/

http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

by: Al

Mon, 06 Oct 2008 09:50:35 +0000

Not positively sure about C++, but Java allows something really simpler:

public class MyClass
{
private final static instance = new MyClass();

public static MyClass getInstance()
{
return instance;
}
}

This ensures the static field is initialized only once. An alternative, if startup code is more complex, is to used a static constructor :

public class MyClass
{
private final static instance;

static {
// some global initialization stuff…
instance = new MyClass();
}

public static MyClass getInstance()
{
return instance;
}
}

This is not to start a C++/Java war ; I’ve made more Java than C++, and want to learn ;)

by: Scottt

Wed, 27 Aug 2008 04:37:20 +0000

A simple alternative is to use a function such as pthread_once on POSIX or the InitOnce methods in Vista which will run a method a single time regardless of how many threads call it.

As EJ notes above, double checked locking will fail on some compilers even if volatile is used. You need to lock for all access to the pointer.

by: EJ

Wed, 21 Nov 2007 03:13:57 +0000

There are issues with this:
http://en.wikipedia.org/wiki/Double-checked_locking

Specifically, compilers may optimize the pInstance in such a way that pInstance will point to a partially constructed object.