What is singleton design pattern?

Singleton design pattern

Singelton Design Pattern.

 The singleton design pattern is a software design pattern which ensures that a class of anyone object has only one instance (of computer science). In other words, we can also say that it restricts the instantiation of a class of any object. We require a singleton pattern because it may sometimes happen that we require only one object to coordinate with the action across the system. This concept is also applicable when we have to restrict instantiation over a number of objects.

The singleton pattern helps us to solve problems like:

• Helps to ensure that a class has one instance.
• Helps to access the sole instance of a class easily.
• Helps to a class to control its instantiation.
• Helps to restrict a number of instances of a class.

Now, you might be thinking about how to solve such problems. Here are a few key points which might help you:

• The first key point is to make a class which is responsible by itself for controlling its instantiations.
• The second point is to hide the constructor (those objects which are created from classes by subroutines) of a class. This is important to do because by doing this you declare privacy that ensures the class would never be instantiated from outside of the class.
• The last point is to define a public static operation (for eg. , getInstance()) as this would return the sole instance of the class and is also easily accessible by using class name and operation name.

Another question might strike you when to use Singleton? Here is the answer to that, you need to use Singleton when you find that these criteria mentioned below are satisfying:

• There must be ownership of a single instance.
• There is no provision of global access.
• And there is lazy initialization (kind of lazy evaluation of instantiation of objects/classes).

Abstract factory, builder and prototype pattern use singleton pattern for their implementations. State objects and façade objects are also singletons. The reason behind why Singleton patterns are more preferable than compared to global variables is that while using Singleton pattern at that time you are sure enough how many numbers of instances you are working with and you can change your mind and manage any number of instances you want to.

 The java class that allows us to create one object per JVM is called a singleton java class.
 E.g
 The Logger class of the Log4j API is given as singleton java class.

 Rules
 To create the singleton class, we need to have the following things.
 1. Static member
 It gets memory only once because of static, it contains the instance of the Singleton class.
 2. Private constructor
 It will prevent to instantiate the Singleton class from outside the class.
 3. Static factory method
 This provides the global point of access to the Singleton object and returns the instance to the caller.

Here is the syntax of Singleton implementation in two very known languages Java 

Singleton implementation in Java

public final class Singleton
{
private static final Singleton INSTANCE = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return INSTANCE;
}
}