Day to day stuff: June 2011

Thursday, June 16, 2011

Lock-less singleton pattern

Although the singleton pattern is now know as an anti-pattern, I think it still is a valid choice when you only need one instance in a particular context. Anyway, in Java there are several ways to implement a singleton.

For example this one uses a synchronized block:

private Singleton singleton = null;

protected Singleton createSingleton() {
  synchronized (this) {  // locking on 'this' for simplicity
    if (singleton == null) {
      singleton = new Singleton();
    }
    return singleton;
  }
}

To prevent locking all the time you can use the double-check idiom on a modern JVM. But I just thought about another implementation that switches locking for preventing code re-ordering, making it a lock-less implementation:

private AtomicReference singletonRef = new AtomicReference(null);

protected Singleton createSingleton() {
  Singleton singleton = singletonRef.get();
  if (singleton == null) {
    singleton = new Singleton();
    if (!singletonRef.weakCompareAndSet(null, singleton)) {
      singleton = singletonRef.get();
    }
  }
  return singleton;
}

There is only one catch to this implementation: although createSingleton() will always return the same instance, it must be allowed to call the constructor of Singleton twice without side-effects.

Update 2011-06-18: changed compareAndSet to weakCompareAndSet as suggested by Adriano.