What is the singleton design pattern?


The singleton pattern is one of the simplest design patterns. A class that uses the singleton design pattern has a single instance that it manages itself. 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 it creates. So any class that wants an instance of a singleton class must access it through its single access point.

Java’s excellent support for object-oriented programming makes it easy to use the singleton design pattern.

Implementing the Singleton pattern using Java

There are many ways to implement the singleton pattern in Java; impatient and lazy approaches are common variations. Each of these approaches has its advantages and disadvantages. Therefore, the method you choose to employ should depend on how your application works.

The enthusiastic approach

Implementing the singleton pattern with the impatient approach means that the class creates a new instance of itself when it loads.

public class EagerSingleton {
private static EagerSingleton instance = new EagerSingleton();

private EagerSingleton() {}

public static EagerSingleton getInstance() {
return instance;

The EagerSingleton The Java class creates a new instance of itself when loaded. It assigns this instance to the private static instance variable, which is only accessible within the singleton class. The only external access point to the instance variable is through the getInstance() method. This method returns the previously created instance of the class.

This approach is great because it avoids the problem of multithreading, which is one of the singleton pattern’s biggest challenges. It solves the multithreading problem by creating a new instance of itself before a new thread can access its instance variable. This ensures that each thread will only have access to the same instance.

However, the impatient approach is only practical if your application uses an instance of the singleton class when it starts. Otherwise, you will create an object before your application needs it, using resources unnecessarily.

The lazy approach

The lazy approach is the solution to the greedy approach problem. It allows you to create a new instance of a singleton class only when your program needs it.

public class LazySingleton {
private volatile static LazySingleton instance;

private LazySingleton() {}

public static LazySingleton getInstance() {
if (instance == null) {
synchronized (LazySingleton.class) {
if (instance == null) {
instance = new LazySingleton();

return instance;

The lazy approach solves the multithreading problem by using synchronized keyword. This prevents two threads from accessing the instance variable at the same time. However, synchronization is expensive, so the application only uses it once, when it calls getInstance() for the first time.

When to use the Singleton pattern

The Singleton pattern is useful in many scenarios, for creating dialog boxes, managing registry settings, or managing thread pools.

Another common use of the singleton pattern is to create a central class that handles database connections.


Comments are closed.