Singleton is a part of Gang of Four design pattern. Patterns are about reusable designs and interactions of objects. Singleton design pattern is a simplest design pattern that have only one instance of a class in an application and provide a global access point to that instance in an application. Print spooler in a system usually used singleton pattern.
Implementations -
1.Static member/variable : This contains the instance of the singleton class.
2.Private constructor : This will prevent anybody else to instantiate the Singleton class.
3.Static public method : This provides the global point of access to the Singleton object and returns the instance to the client calling class.
Uses of Singleton design pattern - Here are the some real situations where Singleton is used.
1.Logger Classes - logger class that used for logging operation is implemented as singleton design pattern that provide a global access point to perform logging operations.
2.Configuration Classes - configuration classes also implemented as singleton design pattern. This classes provide a configuration setting for an application.
3.Accessing resources in shared mode - In an multi-threading environment, singleton with synchronized methods could be used to be used to manage all the operations on the serial port.
Examples of Singleton Class -
public class Singleton
{
private static Singleton instance;
private Singleton()
{
}
public static Singleton GetInstance()
{
if (instance == null)
instance = new Singleton();
return instance;
}
public void DoSomething()
{
}
}
The GetInstance method provide a global access point to the object and it can be used in the following manner:
Singleton.GetInstance().DoSomething();
Implementation Example -
1. Eager initialization - In eager singleton design pattern an instance of a class is created much before it is actually required. Mostly it is done on system start up.
In C# -
public class EagerSingleton
{
private static volatile EagerSingleton instance = new EagerSingleton();
// private constructor
private EagerSingleton()
{
}
public static EagerSingleton GetInstance()
{
get
{
return instance;
}
}
}
In Java -
public class EagerSingleton
{
private static volatile EagerSingleton instance = new EagerSingleton();
// private constructor
private EagerSingleton()
{
}
public static EagerSingleton getInstance()
{
get
{
return instance;
}
}
}
Pros:
1. Works in both single and multithreaded enviornment
Cons:
1. Instance is created irrespective of it is required in runtime or not.
2. Lazy initialization -Lazy initialization of an object means that its creation is deferred until it is first used. It also known as Single Thread Singleton pattern. It used to improve performance, avoid wasteful computation, and reduce program memory requirements.
1. If two threads come to create an instance and run instance is equal to null then both thread create an instance and there are two instances in an application. So we can handle this situation using double-checked locking.
3. Multi-Threaded Singleton Pattern - The solution for problem found in Lazy Singleton pattern is to use the Double-Check Locking. Double Check Locking recheck the instance variable again in lock block in C# ( synchronized in Java).
0 Comment(s)