The singleton design pattern is a common creational design pattern that suggests the instantiation of a class to one “single” instance. Provided the object (instance) has a global access point. SDP is considered as a way of defining a class.
Singleton design pattern is preferred to used where only a single instance of a class is necessary to control the action throughout the execution. A singleton class shouldn’t have multiple instances in any case or at any cost.
Singleton classes are used where it makes sense to have one object in the entire system because initializer(instantiation) calls become expensive if instance represents any resource. For example, instance of the classes that are performing actions like creating Driver objects, Caching and keeping thread pool, logging and establishing Database connections etc…
- The creation of a single instance also helps to ensure that some aspects of our programs cannot be overridden by other classes resulting in unsafe or inefficient code.
- The control of object creation is achieved by implementing a creation method that saves the created object in a static field.
There should be a method within the interface(i.e. interface having one instance), whose duty will be to provide the global access of the Single Instance, serving as Instance Allocator.
For reference, let’s see how to achieve a single instantiation of an object. And, understand the whole procedure parts by part, first we defined the class variable
__instance__, that will hold the single object to be instantiated.
__instance__ = None
Now as we know when we do instantiation, a call to the constructor is made. Here, after a call, the constructor will first check if there is an existing instance or not, if yes raise an error, else create the instance.
def __init__(self): """ Constructor """ if Singleton.__instance__ is None: Singleton.__instance__ = self else: raise Exception("Attempt to create another Instance")
Then there is
get_instance() method, whose duty will be to check whether is there any existing instance or not, if yes it should return the instance, else it should create the new instance. The
get_instance() method is working as an Instance allocator. Since
get_instance() is not specific to an instance, hence kept static.
@staticmethod def get_instance(): """ Static method to get the instance.""" if not Singleton.__instance__: Singleton() return Singleton.__instance__
The full code will look like this:
class Singleton: __instance__ = None def __init__(self): """ Constructor """ if Singleton.__instance__ is None: Singleton.__instance__ = self else: raise Exception("Attempt to create another Instance") @staticmethod def get_instance(): """ Static method to get the instance.""" if not Singleton.__instance__: Singleton() return Singleton.__instance__
However, we have configured the
__init__ function in such a way that, it will raise an error if the call is made to create a second instance. But what if we prefer to return the first instance itself, on the second call. We can use the
class Singleton: __instance__ = None def __new__(cls): # If there is no instance create one if cls.__instance__ is None: cls.__instance__ = super(Singleton, cls).__new__(cls) # If another call is made, return the first instance return cls.__instance__
__new__ has an eye on instance creation as well it is working as an Instance allocator. The line that may seem confusing is
cls.__instance__ = super(Singleton, cls).__new__(cls)
Let’s understand it step by step, Super method is creating a proxy(temporary) object of our Singleton class:
That proxy object makes a call to
__new__ method with
cls as a parameter, and here
cls represents Singleton. That creates the actual object, and we store it in our
These are some implementations on the Singleton Design Pattern, which restricts the instantiation of a class to one object. Mostly Used to limit concurrent access to a shared resource.
But, since there will be only one instance to communicate with the rest of the entities, leading to the development of some hidden dependencies (i.e. tight-coupling) between modules(entities) in certain implementations, making it difficult to track and test, hence keep testing in mind while obeying the Singleton design pattern.
Pros and Cons of the Singleton Design Pattern
- Since there is only one instance of our class it reduces the risk of unexpected behaviour in our program.
- Creation of the object(instance) is controlled by a single class, this offers flexibility since changes only need to be made to one class and object.
- Singleton pattern violates the Single Responsibility Principle since the class may have to handle more than one responsibility at a given time.
- May require several Testings.