Design Patterns: Singleton
A Creational Design Pattern

What is the Singleton Design Pattern?

The Singleton design pattern is one of the Creational patterns and deals with the problem of restricting the creation of objects of a class to a single instance.

Here is the basic formulation of the Singleton design pattern:

• Name
  The name of the design pattern is Singleton.
• Intent
  The intent of this design pattern is to define a class in such a way that no client of that particular class is able to create more than one object of the class. At the same time, a (global) "point of access" must be provided so that any client may have access to the single instance.
• Solution
  In Java, the general formulation of a Singleton class looks like this:

  public class Singleton
  {
      private static Singleton theInstance = new Singleton();
      //Other fields
  
      //Note the private constructor
      private Singleton()
      {
          //Initialize instance fields
      }
  
      public static Singleton getInstance()
      {
          return theInstance;
      }
  
      //Other public methods
  }
  

  An alternate form of this definition that performs lazy initialization of the class instance looks like this:

  public class Singleton
  {
      private static Singleton theInstance
      //Other fields
  
      //Note the private constructor
      private Singleton()
      {
          //Initialize instance fields
      }
  
      public static Singleton getInstance()
      {
          if (theInstance == null)
              theInstance = new Singleton();
          return theInstance;
      }
  
      //Other public methods
  }
  

• Consequences (quoted from Java Design Patterns, by Cooper)
  
  • The question of how to provide the "global access" to the single instance must be addressed, and is usually answered by providing the necessary static members.
  • Subclassing a Singleton class may be tricky, since a subclass object cannot be created unless the superclass object has not yet been created.
  • You may want to extend the Singleton class to allow not just a single instance, but some small fixed maximum number of instances.
• Examples There are many situations in which we want only one of something. Sometimes we may want to enforce this restriction, and sometimes we just don't bother. If we do want to enforce it, however, then the Singleton design pattern is what we need. Here are some examples of when we want only one-of-a-kind:
  • The top-level window in an application
  • A timer for an entire system (in a simulation, say)
  • The Toolkit object or the GraphicsEnvironment object for a Java application

List of All Topics