The singleton pattern is one of the simpler design patterns.
A class that uses the singleton design pattern has a single instance that it manages on its own.
This class prevents any other class from creating an instance of it.
A singleton class also provides a single global access point to the instance that it creates.
Javas excellent support for object-oriented programming makes it easy to use the singleton design pattern.
Each of these approaches has its own merits and drawbacks.
Therefore, the method you choose to employ should depend on how your utility will operate.
TheEagerSingletonJava classcreates a new instance of itself as it loads.
It assigns this instance to the private staticinstance variable, which is only accessible within the singleton class.
The only point of external access to the instance variable is through thegetInstance()method.
That method returns the previously created instance of the class.
This guarantees that each thread will only have access to the same instance.
Otherwise, you’ll create an object before your utility needs it, using resources unnecessarily.
The Lazy Approach
The lazy approach is the solution to the eager approach problem.
It allows you to create a new instance of a singleton class only when your program needs it.
The lazy approach solves the multithreading problem using thesynchronizedkeyword.
This prevents two threads from gaining access to the instance variable at the same time.
Another common use for the singleton pattern is to create a central class that manages database connections.
