11.3.1. Singleton Pattern

Ensures a class has only one instance and provides a global point of access to it.

The Singleton Pattern is a design pattern that restricts the instantiation of a class to only one single object. The main purpose of this pattern is to control access to this instance and to ensure that there is a consistent point of access to that instance throughout the application. This can be particularly useful when a single object is needed to coordinate actions across the system, such as a database connection or a configuration manager.

Imagine a government where the country has only one president at a time. The president is the single point of access for any official decisions or actions that involve governance. Similarly, in programming, a Singleton class provides one point of access to manage shared resources without creating multiple instances that could lead to data inconsistency.

public class Singleton {
private static Singleton instance;
private Singleton() { }
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}

The code snippet provided illustrates the basic implementation of the Singleton Pattern in Java. The class Singleton has a private static variable instance that holds the single instance of the class. The constructor is private, meaning that no external class can create an instance directly. Instead, to access the instance, you call the static method getInstance(). This method checks whether instance is null, and if it is, it creates a new instance. If an instance already exists, it returns the existing instance.

This is akin to a light switch in your home. You don’t want multiple switches controlling the same light bulb, as it could lead to confusion about which switch controls the light. Instead, there is one switch that you use to turn the light on and off, just as the getInstance() method controls access to the single instance of the Singleton class.

When to use the Singleton pattern? Java applications often use the Singleton design pattern for classes like Logger or Configuration Manager.

The Singleton Pattern is particularly useful when you need to ensure that only one instance of a class exists in the application, which can help manage resources efficiently. For example, a Logger instance should be a singleton, as multiple logging instances could lead to inconsistent logging output and reduced performance. Similarly, a Configuration Manager is another example where a single instance can maintain the application’s settings without creating conflicts.

Consider how you manage your home—there is typically one main thermostat that controls the temperature of the house. If there were multiple thermostats, each could send conflicting signals to the HVAC system. By having just one thermostat, you ensure that the temperature setting is consistent throughout the house, just like a Singleton guarantees a single point of control in software.

--