Arvind

• Dec 17th, 2005

 

In computer science, the singleton design pattern is designed to restrict instantiation of a class to one (or a few) objects. This is useful when exactly one object is needed to coordinate actions across the system. Sometimes it is generalized to systems that operate more efficiently when only one or a few objects exist.

The singleton pattern is implemented by creating a class with a method that creates a new instance of the object if one does not exist. If one does exist it returns a reference to the object that already exists. To make sure that the object cannot be instantiated any other way the constructor is made either private or protected.

The singleton pattern must be carefully constructed in multi-threaded applications. If two threads are to execute the creation method at the same time when a singleton does not yet exist, they both must check for an instance of the singleton and then only one should create the new one.

The classic solution to this problem is to use mutual exclusion on the class that indicates that the object is being instantiated.

A Java programming language solution is as follows. It is based on the Q&A link found below, modified for multi-threading, however, it is still vulnerable to the double-checked locking anti-pattern, also found below:

public class Singleton {
    private static Singleton INSTANCE = null;

    // Private constructor suppresses
    // default public constructor
    private Singleton() {}

    //synchronized creator to defend against multi-threading issues
    //another if check here to avoid multiple instantiation
    private synchronized static void createInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Singleton();
        }
    }

    public static Singleton getInstance() {
        if (INSTANCE == null) createInstance();
        return INSTANCE;
    }
}

charlie harvey - http://charlieharvey.org.uk

• Mar 29th, 2006

 

Here's a version that implements double-check locking. The advantage of this is that you only synchronize your thread when it becomes necessary which improves your performance. package singleton. Its worth noting that this only works with JVMs>=1.5, because of problems with the implementation of the volatile keyword in earlier JVMs.public class DoubleLockSynchronizedSingleton { private volatile static DoubleLockSynchronizedSingleton uniqInstance; private String name; private DoubleLockSynchronizedSingleton() { name="" + System.currentTimeMillis(); } // This is the interesting bit public static DoubleLockSynchronizedSingleton getInstance() { if (uniqInstance==null) { synchronized (DoubleLockSynchronizedSingleton.class) { if (uniqInstance==null) uniqInstance = new DoubleLockSynchronizedSingleton(); } } return uniqInstance; }//------------------------------------------------------------------------------------HTHCharlie