Computer Science Design Patterns/Singleton

Singleton examples in various languages

Note: these examples have been moved from Wikipedia to here, since this is a more suitable repository for them.

Scala

The Scala programming language supports Singleton objects out-of-the-box. The 'object' keyword creates a class and also defines a singleton object of that type.

Singletons are declared just like classes except "object" replaces the keyword "class".

object MySingleton {
  println("Creating the singleton")
 
  val i : Int = 0
}

Java

Traditional simple way using synchronization

This solution is thread-safe without requiring special language constructs:

 public class Singleton {
   public volatile static Singleton singleton;//volatile is needed so that multiple thread can reconcile the instance
 
   private Singleton(){}
 
   public static Singleton getSingleton(){//synchronized keyword has been removed from here
     if(singleton==null) {//needed because once there is singleton available no need to aquire monitor again & again as it is costly
       synchronized(Singleton.class){
          if(singleton==null)//this is needed if two threads are waiting at the monitor at the time when singleton was getting instantiated
          singleton= new Singleton();
       }
    }
   return singleton;
  }
 
}

Initialization on Demand Holder Idiom

This technique is as lazy as possible, and works in all known versions of Java. It takes advantage of language guarantees about class initialization, and will therefore work correctly in all Java-compliant compilers and virtual machines.

The nested class is referenced when getInstance() is called making this solution thread-safe without requiring special language constructs.

 public class Singleton {
   // Private constructor prevents instantiation from other classes
   private Singleton() {}
 
   /**
    * SingletonHolder is loaded on the first execution of Singleton.getInstance() 
    * or the first access to SingletonHolder.INSTANCE, not before.
    */
   private static class SingletonHolder { 
     private static final Singleton INSTANCE = new Singleton();
   }
 
   public static Singleton getInstance() {
     return SingletonHolder.INSTANCE;
   }
 }

The Enum-way

In the second edition of his book "Effective Java" Joshua Bloch claims that "a single-element enum type is the best way to implement a singleton" for any Java that supports enums. The use of an enum is very easy to implement and has no drawbacks regarding serializable objects, which have to be circumvented in the other ways.

 public enum Singleton {
   INSTANCE;
 }

D

Singleton pattern in D programming language

import std.stdio;
import std.string;
 
class Singleton(T) {
    private static T instance;
    public static T opCall() {
        if(instance is null) {
            instance = new T;
        }
        return instance;
    }
}
 
class Foo {
    public this() {
        writefln("Foo Constructor");
    }
}
 
void main(){
    Foo a = Singleton!(Foo)();
    Foo b = Singleton!(Foo)();
}

Or in this manner

// this class should be in a package to make private this() not visible
class Singleton {
    private static Singleton instance;
 
    public static Singleton opCall() {
        if(instance is null) {
            instance = new Singleton();
        }
        return instance;
    }
 
    private this() {
        writefln("Singleton constructor");
    }
}
 
void main(){
    Singleton a = Singleton();
    Singleton b = Singleton();
}

PHP 5

Singleton pattern in PHP 5:

<?php
class Singleton {
 
  // object instance
  private static $instance;
 
  // The protected construct prevents instantiating the class externally.  The construct can be
  // empty, or it can contain additional instructions...
  // This should also be final to prevent extending objects from overriding the constructor with 
  // public.
  protected final function __construct() {
    ...
  }
 
  // The clone and wakeup methods prevents external instantiation of copies of the Singleton class,
  // thus eliminating the possibility of duplicate objects.  The methods can be empty, or
  // can contain additional code (most probably generating error messages in response
  // to attempts to call).
  public function __clone() {
    trigger_error('Clone is not allowed.', E_USER_ERROR);
  }
 
  public function __wakeup() {
    trigger_error('Deserializing is not allowed.', E_USER_ERROR);
  }
 
  //This method must be static, and must return an instance of the object if the object
  //does not already exist.
  public static function getInstance() {
    if (!self::$instance instanceof self) { 
      self::$instance = new self;
    }
    return self::$instance;
  }
 
  //One or more public methods that grant access to the Singleton object, and its private
  //methods and properties via accessor methods.
  public function doAction() {
    ...
  }
}
 
//usage
Singleton::getInstance()->doAction();
 
?>

Actionscript 3.0

Private constructors are not available in ActionScript 3.0 - which prevents the use of the ActionScript 2.0 approach to the Singleton Pattern. Many different AS3 Singleton implementations have been published around the web.

package {
        public class Singleton  {
 
                private static var _instance:Singleton = new Singleton();
 
                public function Singleton () {        
                    if (_instance){
                        throw new Error( 
                            "Singleton can only be accessed through Singleton.getInstance()" 
                        );
                    }
                }
 
                public static function getInstance():Singleton {
                        return _instance;
                }
 
        }
}

Objective-C

A common way to implement a singleton in Objective-C is the following:

@interface MySingleton : NSObject
{
}
 
+ (MySingleton *)sharedSingleton;
@end
 
@implementation MySingleton
 
+ (MySingleton *)sharedSingleton
{
  static MySingleton *sharedSingleton;
 
  @synchronized(self)
  {
    if (!sharedSingleton)
      sharedSingleton = [[MySingleton alloc] init];
 
    return sharedSingleton;
  }
}
 
@end

If thread-safety is not required, the synchronization can be left out, leaving the +sharedSingleton method like this:

+ (MySingleton *)sharedSingleton
{
  static MySingleton *sharedSingleton;
 
  if (!sharedSingleton)
    sharedSingleton = [[MySingleton alloc] init];
 
  return sharedSingleton;
}

This pattern is widely used in the Cocoa frameworks (see for instance, NSApplication, NSColorPanel, NSFontPanel or NSWorkspace, to name but a few).

Some may argue that this is not, strictly speaking, a Singleton, because it is possible to allocate more than one instance of the object. A common way around this is to use assertions or exceptions to prevent this double allocation.

@interface MySingleton : NSObject
{
}
 
+ (MySingleton *)sharedSingleton;
@end
 
@implementation MySingleton
 
static MySingleton *sharedSingleton;
 
+ (MySingleton *)sharedSingleton
{
  @synchronized(self)
  {
    if (!sharedSingleton)
      [[MySingleton alloc] init];
 
    return sharedSingleton;
  }
}
 
+(id)alloc
{
  @synchronized(self)
  {
    NSAssert(sharedSingleton == nil, @"Attempted to allocate a second instance of a singleton.");
    sharedSingleton = [super alloc];
    return sharedSingleton;
  }
}
 
@end

There are alternative ways to express the Singleton pattern in Objective-C, but they are not always as simple or as easily understood, not least because they may rely on the -init method returning an object other than self. Some of the Cocoa "Class Clusters" (e.g. NSString, NSNumber) are known to exhibit this type of behaviour.

Note that @synchronized is not available in some Objective-C configurations, as it relies on the NeXT/Apple runtime. It is also comparatively slow, because it has to look up the lock based on the object in parentheses. Check the history of this page for a different implementation using an NSConditionLock.

C#

The simplest of all is:

public class Singleton
{
    // The combination of static and readonly makes the instantiation 
    // thread safe.  Plus the constructor being protected (it can be 
    // private as well), makes the class sure to not have any other 
    // way to instantiate this class than using this member variable.
    public static readonly Singleton Instance = new Singleton();
 
    // Protected constructor is sufficient to avoid other instantiation
    // This must be present otherwise the compiler provides a default 
    // public constructor
    //
    protected Singleton()
    {
    }
}

This example is thread-safe with lazy initialization. Note that the explicit static constructor which disables beforefieldinit. See http://www.yoda.arachsys.com/csharp/beforefieldinit.html

/// Class implements singleton pattern.
 
public class Singleton
{
        // Protected constructor is sufficient to avoid other instantiation
        // This must be present otherwise the compiler provides 
        // a default public constructor
        protected Singleton()
        {
        }
 
 
        /// Return an instance of <see cref="Singleton"/>
 
        public static Singleton Instance
        {
            get
            {
                /// An instance of Singleton wont be created until the very first 
                /// call to the sealed class. This is a CLR optimization that
                /// provides a properly lazy-loading singleton. 
                return SingletonCreator.CreatorInstance;
            }
        }
 
 
        /// Sealed class to avoid any heritage from this helper class
 
        private sealed class SingletonCreator
        {
          // Retrieve a single instance of a Singleton
          private static readonly Singleton _instance = new Singleton();
 
          //explicit static constructor to disable beforefieldinit
          static SingletonCreator() { }
 
          /// Return an instance of the class <see cref="Singleton"/>
 
          public static Singleton CreatorInstance
          {
            get { return _instance; }
          }
        }
}

Example in C# 2.0 (thread-safe with lazy initialization) Note: This is not a recommended implementation because "TestClass" has a default public constructor, and that violates the definition of a Singleton. A proper Singleton must never be instantiable more than once. More about generic singleton solution in C#: http://www.c-sharpcorner.com/UploadFile/snorrebaard/GenericSingleton11172008110419AM/GenericSingleton.aspx

/// Parent for singleton
 
/// <typeparam name="T">Singleton class</typeparam>
  public class Singleton<T> where T : class, new()
  {
 
    protected Singleton() { }
 
    private sealed class SingletonCreator<S> where S : class, new()
    {
      private static readonly S instance = new S();
 
      //explicit static constructor to disable beforefieldinit      
      static SingletonCreator() { }
 
      public static S CreatorInstance
      {
        get { return instance; }
      }
    }
 
    public static T Instance
    {
      get { return SingletonCreator<T>.CreatorInstance; }
    }
 
  }
 
 
/// Concrete Singleton
 
public class TestClass : Singleton<TestClass>
{
    public string TestProc()
    {
        return "Hello World";
    }
}
 
// Somewhere in the code
.....
TestClass.Instance.TestProc();
.....

Delphi

As described by James Heyworth in a paper presented to the Canberra PC Users Group Delphi SIG on 11/11/1996, there are several examples of the Singleton pattern built into the Delphi Visual Component Library. This unit demonstrates the techniques that were used in order to create both a Singleton component and a Singleton object:

unit Singletn;
 
interface
 
uses
  SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,
  Forms, Dialogs;
 
type
 
  TCSingleton = class(TComponent)
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  end;
 
  TOSingleton = class(TObject)
  public
    constructor Create;
    destructor Destroy; override;
  end;
 
var
  Global_CSingleton: TCSingleton;
  Global_OSingleton: TOSingleton;
 
procedure Register;
 
implementation
 
procedure Register;
begin
  RegisterComponents('Design Patterns', [TCSingleton]);
end;
 
{ TCSingleton }
 
constructor TCSingleton.Create(AOwner: TComponent);
begin
  if Global_CSingleton <> nil then
    {NB could show a message or raise a different exception here}
    Abort
  else begin
    inherited Create(AOwner);
    Global_CSingleton := Self;
  end;
end;
 
destructor TCSingleton.Destroy;
begin
  if Global_CSingleton = Self then
    Global_CSingleton := nil;
  inherited Destroy;
end;
 
 
{ TOSingleton }
 
constructor TOSingleton.Create;
begin 
if Global_OSingleton <> nil then
    {NB could show a message or raise a different exception here}
    Abort
  else
    Global_OSingleton := Self;
end;
 
destructor TOSingleton.Destroy;
begin
  if Global_OSingleton = Self then
    Global_OSingleton := nil;
  inherited Destroy;
end;
 
procedure FreeGlobalObjects; far;
begin
  if Global_CSingleton <> nil then
    Global_CSingleton.Free;
  if Global_OSingleton <> nil then
    Global_OSingleton.Free;
end;
 
begin
  AddExitProc(FreeGlobalObjects);
end.

Python

The desired properties of the Singleton pattern can most simply be encapsulated in Python by defining a module, containing module-level variables and functions. To use this modular Singleton, client code merely imports the module to access its attributes and functions in the normal manner. This sidesteps many of the wrinkles in the explicitly-coded versions below, and has the singular advantage of requiring zero lines of code to implement.

According to influential Python programmer Alex Martelli, The Singleton design pattern (DP) has a catchy name, but the wrong focus—on identity rather than on state. The Borg design pattern has all instances share state instead. A rough consensus in the Python community is that sharing state among instances is more elegant, at least in Python, than is caching creation of identical instances on class initialization. Coding shared state is nearly transparent:

class Borg:
   __shared_state = {}
   def __init__(self):
       self.__dict__ = self.__shared_state
   # and whatever else is needed in the class -- that's all!

But with the new style class, this is a better solution, because only one instance is created:

class Singleton (object):
    def __new__(cls, *args, **kwargs): 
        if not hasattr(cls, 'self'):
            cls.self = object.__new__(cls)
        return cls.self
 
#Usage
mySingleton1 = Singleton()
mySingleton2 = Singleton()
 
#mySingleton1 and  mySingleton2 are the same instance.
assert mySingleton1 is mySingleton2

Two caveats:

• The __init__-method is called every time Singleton() is called, unless cls.__init__ is set to an empty function.
• If it is needed to inherit from the Singleton-class, instance should probably be a dictionary belonging explicitly to the Singleton-class.

class  InheritableSingleton (object):
    instances = {}
    def __new__(cls, *args, **kwargs): 
        if InheritableSingleton.instances.get(cls) is None:
            cls.__original_init__ = cls.__init__
            InheritableSingleton.instances[cls] = object.__new__(cls, *args, **kwargs)
        elif cls.__init__ == cls.__original_init__:
            def nothing(*args, **kwargs):
                pass
            cls.__init__ = nothing
        return InheritableSingleton.instances[cls]

To create a singleton that inherits from a non-singleton, multiple inheritance must be used.

class  Singleton (NonSingletonClass, object):
    instance = None       
    def __new__(cls, *args, **kargs): 
        if cls.instance is None:
            cls.instance = object.__new__(cls, *args, **kargs)
        return cls.instance

Be sure to call the NonSingletonClass's __init__ function from the Singleton's __init__ function.

A more elegant approach using metaclasses was also suggested.

class SingletonType(type):
    def __call__(cls):
        if getattr(cls, '__instance__', None) is None:
            instance = cls.__new__(cls)
            instance.__init__()
            cls.__instance__ = instance
        return cls.__instance__
 
# Usage
class Singleton(object):
    __metaclass__ = SingletonType
 
    def __init__(self):
        print '__init__:', self
 
class OtherSingleton(object):
    __metaclass__ = SingletonType
 
    def __init__(self):
        print 'OtherSingleton __init__:', self
 
# Tests
s1 = Singleton()
s2 = Singleton()
assert s1
assert s2
assert s1 is s2
 
os1 = OtherSingleton()
os2 = OtherSingleton()
assert os1
assert os2
assert os1 is os2

Perl

In Perl version 5.10 or newer a state variable can be used.

package MySingletonClass;
use strict;
use warnings;
use 5.10;
 
sub new {
    my ($class) = @_;
    state $the_instance;
 
    if (! defined $the_instance) {
        $the_instance = bless { }, $class;
    }
    return $the_instance;
}

In older Perls, just use a global variable.

package MySingletonClass;
use strict;
use warnings;
 
my $THE_INSTANCE;
sub new {
    my ($class) = @_;
 
    if (! defined $THE_INSTANCE) {
        $THE_INSTANCE = bless { }, $class;
    }
    return $THE_INSTANCE;
}

If Moose is used, there is the MooseX::Singleton extension module.

Ruby

In Ruby, just include the Singleton module from the standard library into the class.

require 'singleton'
 
class Example
  include Singleton
end
 
# Access to the instance:
Example.instance

ABAP Objects

In ABAP Objects, to make instantiation private, add an attribute of type ref to the class, and a static method to control instantiation.

program pattern_singleton.

***********************************************************************

   * Singleton
   * =========
   * Intent

*

   * Ensure a class has only one instance, and provide a global point
   * of access to it.

***********************************************************************

class lcl_Singleton definition create private.

  public section.

  class-methods:
    get_Instance returning value(Result) type ref to lcl_Singleton.

  private section.
    class-data:
      fg_Singleton type ref to lcl_Singleton.

endclass.

class lcl_Singleton implementation.

  method get_Instance.
    if ( fg_Singleton is initial ).
      create object fg_Singleton.
    endif.
    Result = fg_Singleton.
  endmethod.

endclass.