Singleton pattern

The singleton[4] design pattern is one of the twenty-three well-known "Gang of Four" design patterns that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.

The singleton design pattern solves problems like:[5]

• How can it be ensured that a class has only one instance?
• How can the sole instance of a class be accessed easily?
• How can a class control its instantiation?
• How can the number of instances of a class be restricted?

The singleton design pattern describes how to solve such problems:

• Hide the constructor of the class.
• Define a public static operation (getInstance()) that returns the sole instance of the class.

The key idea in this pattern is to make the class itself responsible for controlling its instantiation (that it is instantiated only once).
The hidden constructor (declared private) ensures that the class can never be instantiated from outside the class.
The public static operation can be accessed easily by using the class name and operation name (Singleton.getInstance()).

• The abstract factory,factory method, builder, and prototype patterns can use singletons in their implementation.
• Facade objects are often singletons because only one facade object is required.
• State objects are often singletons.
• Singletons are often preferred to global variables because:
  • They do not pollute the global namespace (or, in languages with nested namespaces, their containing namespace) with unnecessary variables.[4]
  • They permit lazy allocation and initialization, whereas global variables in many languages will always consume resources.

An implementation of the singleton pattern must:

• ensure that only one instance of the singleton class ever exists; and
• provide global access to that instance.

Typically, this is done by:

• declaring all constructors of the class to be private; and
• providing a static method that returns a reference to the instance.

The instance is usually stored as a private static variable; the instance is created when the variable is initialized, at some point before the static method is first called. The following is a sample implementation written in Java.

public final class Singleton {

    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

public sealed class Singleton {

    private static readonly Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton Instance {
        get {
            return INSTANCE;
        }
    }
}

public static class Singleton {

    private static readonly MyOtherClass INSTANCE = new MyOtherClass();

    public static MyOtherClass Instance {
        get {
            return INSTANCE;
        }
    }
}

public final class Singleton {

    private static volatile Singleton instance = null;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }

        return instance;
    }
}

1 class Singleton {
2     
3     static Singleton _instance;
4     
5     static Singleton get instance => _instance ?? Singleton._();
6     
7     Singleton._() => _instance = this;
8 }

 1 class Singleton {
 2     private static $instance = null;
 3 
 4     private function __construct(){}
 5 
 6     public static function getInstance(): self
 7     {
 8         if (null === self::$instance) {
 9             self::$instance = new self();
10         }
11 
12         return self::$instance;
13     }
14 }

 1 public class Coin {
 2 
 3     private static final int ADD_MORE_COIN = 10;
 4     private int coin;
 5     private static Coin instance = new Coin(); // Eagerly Loading of singleton instance
 6 
 7     private Coin(){
 8         // private to prevent anyone else from instantiating
 9     }
10 
11     public static Coin getInstance(){
12         return instance;
13     }
14 
15     public int getCoin(){
16         return coin;
17     }
18 
19     public void addMoreCoin(){
20         coin += ADD_MORE_COIN;
21     }
22 
23     public void deductCoin(){
24         coin--;
25     }
26 }

 1 object Coin{
 2     private var coin: Int = 0
 3 
 4     fun getCoin():Int{
 5         return coin
 6     }
 7 
 8     fun addCoin(){
 9         coin += 10
10     }
11 
12     fun deductCoin(){
13         coin--
14     }
15 }

unit SingletonPattern;

interface

type
  TTest = class sealed
  strict private
    FCreationTime: TDateTime;
  public
    constructor Create;
    property CreationTime: TDateTime read FCreationTime;
  end;

function GetInstance: TTest;

implementation

uses
  SysUtils
  , SyncObjs
  ;

var
  FCriticalSection: TCriticalSection;
  FInstance: TTest;

function GetInstance: TTest;
begin
  FCriticalSection.Acquire;
  try
    if not Assigned(FInstance) then
      FInstance := TTest.Create;

    Result := FInstance;
  finally
    FCriticalSection.Release;
  end;
end;

constructor TTest.Create;
begin
  inherited Create;
  FCreationTime := Now;
end;

initialization
  FCriticalSection := TCriticalSection.Create;

finalization
  FreeAndNil(FCriticalSection);

end.

procedure TForm3.btnCreateInstanceClick(Sender: TObject);
var
  i: integer;
begin
  for i := 0 to 5 do
    ShowMessage(DateTimeToStr(GetInstance.CreationTime));
end;

The Wikibook Computer Science/Design Patterns has a page on the topic of: Singleton implementations in various languages

Wikimedia Commons has media related to Singleton pattern.

• Complete article "Singleton Design Pattern techniques"
• Four different ways to implement singleton in Java "Ways to implement singleton in Java"
• Book extract: Implementing the Singleton Pattern in C# by Jon Skeet
• Singleton at Microsoft patterns & practices Developer Center
• IBM article "Double-checked locking and the Singleton pattern" by Peter Haggar
• IBM article "Use your singletons wisely" by J. B. Rainsberger
• Javaworld article "Simply Singleton" by David Geary
• Google article "Why Singletons Are Controversial"
• Google Singleton Detector (analyzes Java bytecode to detect singletons)