CSC/ECE 517 Fall 2010/ch3 3f DF

The Singleton pattern in static and dynamic languages

Introduction

The Singleton design pattern ensures that there is no more than one instance of an object in existence at a time. This is accomplished by protecting the allocation and deallaction methods of the class to restrict them from general use. Instead of calling these methods directly, all requests for the object are routed through a public interface which only creates the object if it doesn't exist already. Upon creation, the object is stored in a class variable and this single instance is also returned to all future callers.

UML Diagram

Static Language Implementation

Below is a static language (C++) implementation of the Singleton pattern.

class MySingleton
{
  public:
    static MySingleton* Instance()
    {
      if(s_pSingletonObject == NULL)
        s_pSingletonObject = new MySingleton;
				
      return s_pSingletonObject;
    }
		
    static void Destroy()
    {
      if(s_pSingletonObject != NULL)
      {
        delete s_pSingletonObject;
        s_pSingletonObject = NULL;
      }
    }

    //Begin interface functions
    //...
    //End interface functions
		
  private:
    //Direct access to the constructor/destructor is prohibited
    MySingleton() {}
    virtual ~MySingleton() {}
		
    static MySingleton* s_pSingletonObject;
};

MySingleton::s_pSingletonObject = NULL;

Dynamic Language Implementation

Below is a dynamic language (Ruby) implementation of the Singleton pattern.

Implementation

  Singleton pattern source code

Usage

class MySingleton
  include Singleton

  # Begin interface methods
  # ...
  # End interface methods
end

Variations

Multiple Instantiations

While the Singleton pattern's namesake arises out of there being a "single" instantiation of the class, it is somtimes used to created a fixed number of instantiations. In these situations, the singleton's accessor methods are parameterized to allow callers to specify which instance of the object they desire.

MySingleton* Instance(unsigned int uiInstanceNumber)

Lifetime & Scoping

The Singleton pattern is also commonly varied by modifying the lifetime of the instaniated object. Some implementations allow for a singleton to exist through the entire application lifetime. Other, such as the window state manager below, dynamically create and destroy the singleton as needed.

class MyWindow
{
  Open()
  {
    MyStateSingleton::Instance();
  }

  Close()
  {
    MyStateSingleton::Destroy();
  }
}

References

http://ruby-doc.org/stdlib/libdoc/singleton/rdoc/index.html

http://en.wikipedia.org/wiki/Singleton_pattern