Singleton
The term Singleton refers to an object that can be instantiated only once. Use the Singleton Design pattern if:
- You need global access to a resource, like logging ...
- You need only one instance of a utility class, do not want to create lots of objects.
In some applications, it is appropriate to enforce a single instance of an object, for example: window managers, print spoolers, database access, and filesystems.
Refresh Java object creation
In programming languages like Java, you have to create an instance of an object type (commonly called a Class) to use it throughout the code. Let's take for example this code:
Animal dog; // Declaring the object type
dog = new Animal(); // Instantiating an object
This can also be written in a single line to save space.
Animal dog = new Animal(); // Both declaring and instantiating
At times, you need more than one instance of the same object type. You can create multiple instances of the same object type. Take for instance:
Animal dog = new Animal();
Animal cat = new Animal();
Now that I have two instances of the same object type, I can use both dog and cat instances separately in my program. Any changes to dog would not effect the cat instance because both of them have been created in separate memory spaces. To see whether these objects actually are different we do something like this:
System.out.println(dog.equals(cat)); // output: false
The code returns false because both the objects are different. Contrary to this behavior, the Singleton behaves differently. A Singleton object type can not be instantiated yet you can obtain an instance of the object type. Let us create a normal object using Java.
class NormalObject {
public NormalObject() {
}
}
What we have done here is that we have created a class (object type) to identify our object. Within the braces of the class is a single method with the same name as that of the class (methods can be identified by the usage of parentheses at the end of their names). Methods that have the same name as that of the class and that do not have a return type are called Constructors in OOP syntax. To create an instance of the class, the code can not be much simpler.
class TestHarness {
public static void main(String[] args) {
NormalObject object = new NormalObject();
}
}
Note that to encourage the instantiation of this object, the constructor is called. The constructor as in this case can be called outside the class paranthesis and into another class definition because it is declared a public accessor while creating the Constructor in the above example.
- Creating singleton object
Now we will create the Singleton object. You just have to change one thing to adhere to the Singleton design pattern: Make your Constructor's accessor private.
class SingletonObject {
private SingletonObject() {
}
}
Notice the constructor's accessor. This time around it has been declared private. Just by changing it to private, you have applied a great change to your object type. Now you can not instantiate the object type. Go ahead try out the following code.
class TestHarness {
public static void main(String[] args) {
SingletonObject object = new SingletonObject();
}
}
The code returns an error because private class members can not be accessed from outside the class itself and in another class. This way you have disabled the instantiation process for an object type. However, you have to find a way of obtaining an instance of the object type. Let's do some changes here.
class SingletonObject {
private static SingletonObject object;
private SingletonObject() {
// Instantiate the object.
}
public static SingletonObject getInstance() {
if (object == null) {
object = new SingletonObject(); // Create the object for the first and last time
}
return object;
}
}
The changes involve adding a static class field called object and a public static method that can be accessible outside the scope of the class by using the name of the Class. To see how we can obtain the instance, lets code:
class TestHarness {
public static void main(String[] args) {
SingletonObject object = SingletonObject.getInstance();
}
}
This way you control the creation of objects derived from your class. But we have still not unearthed the final and interesting part of the whole process. Try getting multiple objects and see what happens.
class TestHarness {
public static void main(String[] args) {
SingletonObject object1 = SingletonObject.getInstance();
SingletonObject object2 = SingletonObject.getInstance();
}
}
Unlike multiple instances of normal object types, multiple instances of a Singleton are all actually the same object instance. To validate the concept in Java, we try:
System.out.println(object1.equals(object2)); // output: true
The code returns true because both object declarations are actually referring to the same object. So, in summarizing the whole concept, a Singleton can be defined as an object that can not be instantiated more than once. Typically it is obtained using a static custom implementation.
Singleton & Multi Threading
Java uses multi threading concept, to run/execute any program. Consider the class SingletonObject discussed above. Call to the method getInstance() by more than one thread at any point of time might create two instances of SingletonObject thus defeating the whole purpose of creating the singleton pattern. To make singelton thread safe, we have three options:
1. Synchronize the method getInstance(), which would look like:
// Only one thread can enter and stay in this method at a time
public synchronized static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
Synchronizing the method guarantees that the method will never be called twice at the same time. The problem with the above code is that 'synchronization' is expensive. 'Synchronization' checks will occur every time the function is called. Therefore, the above code should not be the first option. 2. Another approach would be to create a singleton instance as shown below:
class SingletonObject {
private volatile static SingletonObject object;
private final static Object lockObj = new Object(); // Use for locking
private SingletonObject() {
// Exists only to avoid instantiation.
}
public static SingletonObject getInstance() {
if (object != null) {
return object;
} else {
// Start a synchronized block, only one thread can enter and stay in the block one at a time
synchronized(lockObj) {
if (object == null) {
object = new SingletonObject();
}
} // End of synchronized block
return object;
}
}
}
The above code will be much faster; once the singleton instance is created no synchronization is needed. It just returns the same instance reference. 3. Use static initialization block to create the instance. The JVM makes sure that the static block is executed once when the class is loaded.
class SingletonObject {
public final static SingletonObject object;
static {
...
object = new SingletonObject();
}
private SingletonObject() {
// Exists only to avoid instantiation.
}
public static SingletonObject getInstance() {
return object;
}
}
Examples
In Java, the class java.lang.Runtime is a singleton. Its constructor is protected and you can get an instance by calling the getRuntime() method.
Cost
Beware of this design pattern! It creates the same issues than the global variables in procedural programming so it can be hard to debug.
Creation
It can be expensive. You may have to refactor all the instantiations of the class, unless the class is new.
Maintenance
There is no additional cost.
Removal
This pattern can be easily removed as automatic refactoring operations can easily remove its existence.
Advises
- Name the method
getInstance()to indicate the use of the pattern to the other developers. - Use this design pattern for frozen data like configuration or external data. You will not have debugging issues.
Implementation
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
}
Traditional simple way using synchronization
This solution is thread-safe without requiring special language constructs:
public class Singleton {
private 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;
}
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();
}
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();
?>
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;
}
}
}
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.
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.
/// Class implements singleton pattern.
public class Singleton
{
//Use Lazy<T> to lazily initialize the class and provide thread-safe access
private static readonly Lazy<Singleton> _lazyInstance = new Lazy<Singleton>(() => new Singleton());
public static Singleton Instance
{
get { return _lazyInstance.Value; }
}
private Singleton() { }
}
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();
.....
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.
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
In Perl version 5.10 or newer a state variable can be used.
package MySingletonClass;
use strict;
use warnings;
use 5.010;
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.
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
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.
