Singleton Pattern in Java

Introduction

Imagine you have a settings manager in your application. You only need one instance of this manager throughout your entire program because all parts of your app should use the same settings. If you create multiple instances, they might have different configurations and cause chaos!

The Singleton Pattern ensures that a class has only one instance and provides a global point of access to that instance. It's like having only one captain on a ship—everyone takes directions from the same person.

What is the Singleton Pattern?

The Singleton Pattern is a creational design pattern that restricts the instantiation of a class to a single object. It's used when exactly one object is needed to coordinate actions across the system.

Key Characteristics:

✅ Only one instance throughout application lifetime
✅ Global access point to that instance
✅ Controlled instantiation - prevents external creation
✅ Lazy initialization - created only when needed

Code Explanation with Examples

Example 1: Basic Singleton (Eager Initialization)

public class BasicSingleton {
// 1. Private static instance - created when class loads
private static final BasicSingleton instance = new BasicSingleton();
// 2. Private constructor - prevents external instantiation
private BasicSingleton() {
System.out.println("BasicSingleton instance created!");
}
// 3. Public static method to get the instance
public static BasicSingleton getInstance() {
return instance;
}
// Business method
public void showMessage() {
System.out.println("Hello from BasicSingleton!");
}
}
// Usage
public class SingletonDemo {
public static void main(String[] args) {
// Get the singleton instance
BasicSingleton singleton1 = BasicSingleton.getInstance();
BasicSingleton singleton2 = BasicSingleton.getInstance();
singleton1.showMessage();
// Check if both references point to same object
System.out.println("Same instance? " + (singleton1 == singleton2)); // true
System.out.println("singleton1 hash: " + singleton1.hashCode());
System.out.println("singleton2 hash: " + singleton2.hashCode());
}
}

Output:

BasicSingleton instance created!
Hello from BasicSingleton!
Same instance? true
singleton1 hash: 1324119927
singleton2 hash: 1324119927

Example 2: Lazy Initialization Singleton

public class LazySingleton {
// 1. Private static instance - not created until needed
private static LazySingleton instance;
// 2. Private constructor
private LazySingleton() {
System.out.println("LazySingleton instance created!");
}
// 3. Public static method with lazy initialization
public static LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
public void doWork() {
System.out.println("LazySingleton is working...");
}
}
// Usage
public class LazyDemo {
public static void main(String[] args) {
System.out.println("Application started");
// Instance created only when first requested
LazySingleton singleton = LazySingleton.getInstance();
singleton.doWork();
// Subsequent calls return the same instance
LazySingleton anotherReference = LazySingleton.getInstance();
System.out.println("Same instance? " + (singleton == anotherReference));
}
}

Output:

Application started
LazySingleton instance created!
LazySingleton is working...
Same instance? true

Example 3: Thread-Safe Singleton (Synchronized Method)

public class ThreadSafeSingleton {
private static ThreadSafeSingleton instance;
private ThreadSafeSingleton() {
System.out.println("ThreadSafeSingleton instance created!");
}
// Synchronized method for thread safety
public static synchronized ThreadSafeSingleton getInstance() {
if (instance == null) {
instance = new ThreadSafeSingleton();
}
return instance;
}
public void processData(String data) {
System.out.println("Processing: " + data);
}
}
// Usage with multiple threads
public class ThreadSafeDemo {
public static void main(String[] args) {
Runnable task = () -> {
ThreadSafeSingleton singleton = ThreadSafeSingleton.getInstance();
singleton.processData(Thread.currentThread().getName());
};
// Create multiple threads
Thread thread1 = new Thread(task, "Thread-1");
Thread thread2 = new Thread(task, "Thread-2");
Thread thread3 = new Thread(task, "Thread-3");
thread1.start();
thread2.start();
thread3.start();
}
}

Example 4: Double-Checked Locking (Most Efficient)

public class DoubleCheckedSingleton {
// volatile ensures multiple threads handle instance correctly
private static volatile DoubleCheckedSingleton instance;
private DoubleCheckedSingleton() {
System.out.println("DoubleCheckedSingleton instance created!");
}
public static DoubleCheckedSingleton getInstance() {
// First check (without synchronization)
if (instance == null) {
// Synchronize only when instance is null
synchronized (DoubleCheckedSingleton.class) {
// Second check (with synchronization)
if (instance == null) {
instance = new DoubleCheckedSingleton();
}
}
}
return instance;
}
public void performTask() {
System.out.println("Task performed by DoubleCheckedSingleton");
}
}

Example 5: Bill Pugh Singleton (Initialization-on-demand Holder)

public class BillPughSingleton {
// Private constructor
private BillPughSingleton() {
System.out.println("BillPughSingleton instance created!");
}
// Static inner helper class - loaded only when getInstance() is called
private static class SingletonHelper {
private static final BillPughSingleton INSTANCE = new BillPughSingleton();
}
public static BillPughSingleton getInstance() {
return SingletonHelper.INSTANCE;
}
public void serve() {
System.out.println("BillPughSingleton serving your request!");
}
}
// Usage
public class BillPughDemo {
public static void main(String[] args) {
BillPughSingleton singleton = BillPughSingleton.getInstance();
singleton.serve();
}
}

Example 6: Real-World Configuration Manager

import java.util.*;
// Real-world example: Application Configuration Manager
public class ConfigurationManager {
private static ConfigurationManager instance;
private Properties properties;
private ConfigurationManager() {
loadConfiguration();
System.out.println("ConfigurationManager initialized");
}
public static synchronized ConfigurationManager getInstance() {
if (instance == null) {
instance = new ConfigurationManager();
}
return instance;
}
private void loadConfiguration() {
properties = new Properties();
// In real application, load from file/database
properties.setProperty("database.url", "jdbc:mysql://localhost:3306/mydb");
properties.setProperty("database.username", "admin");
properties.setProperty("database.password", "secret");
properties.setProperty("app.version", "1.0.0");
properties.setProperty("max.connections", "10");
}
public String getProperty(String key) {
return properties.getProperty(key);
}
public void setProperty(String key, String value) {
properties.setProperty(key, value);
}
public void displayConfig() {
System.out.println("=== Application Configuration ===");
properties.forEach((key, value) -> 
System.out.println(key + " = " + value));
}
}
// Usage throughout application
public class App {
public static void main(String[] args) {
// Different parts of application access same config
ConfigurationManager config1 = ConfigurationManager.getInstance();
ConfigurationManager config2 = ConfigurationManager.getInstance();
System.out.println("Same config instance? " + (config1 == config2));
// Use configuration
System.out.println("Database URL: " + config1.getProperty("database.url"));
System.out.println("App Version: " + config1.getProperty("app.version"));
config1.displayConfig();
}
}

Example 7: Logger Singleton

import java.io.*;
import java.time.LocalDateTime;
// Real-world example: Logger
public class Logger {
private static Logger instance;
private PrintWriter writer;
private Logger() {
try {
// Open log file
writer = new PrintWriter(new FileWriter("application.log", true));
System.out.println("Logger initialized");
} catch (IOException e) {
e.printStackTrace();
}
}
public static synchronized Logger getInstance() {
if (instance == null) {
instance = new Logger();
}
return instance;
}
public void log(String level, String message) {
String logEntry = String.format("[%s] %s: %s", 
LocalDateTime.now(), level, message);
writer.println(logEntry);
writer.flush(); // Ensure message is written immediately
}
public void info(String message) {
log("INFO", message);
}
public void error(String message) {
log("ERROR", message);
}
public void warn(String message) {
log("WARN", message);
}
public void close() {
if (writer != null) {
writer.close();
}
}
}
// Usage across different classes
public class UserService {
private Logger logger = Logger.getInstance();
public void createUser(String username) {
logger.info("Creating user: " + username);
// Business logic...
logger.info("User created successfully: " + username);
}
}
public class OrderService {
private Logger logger = Logger.getInstance();
public void processOrder(String orderId) {
logger.info("Processing order: " + orderId);
// Business logic...
logger.warn("Order processing taking longer than expected: " + orderId);
}
}
// Demo
public class LoggerDemo {
public static void main(String[] args) {
UserService userService = new UserService();
OrderService orderService = new OrderService();
userService.createUser("john_doe");
orderService.processOrder("ORD-12345");
// All log messages go to the same file through same Logger instance
}
}

Example 8: Enum Singleton (Best Practice)

// Using Enum is the simplest and safest way to implement Singleton
public enum EnumSingleton {
INSTANCE; // The single instance
// Instance variables
private int value;
private String name;
// Methods
public void doSomething() {
System.out.println("EnumSingleton doing something with value: " + value);
}
// Getters and setters
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// Usage
public class EnumSingletonDemo {
public static void main(String[] args) {
EnumSingleton singleton1 = EnumSingleton.INSTANCE;
EnumSingleton singleton2 = EnumSingleton.INSTANCE;
singleton1.setValue(42);
singleton1.setName("MySingleton");
singleton2.doSomething(); // Uses the same instance!
System.out.println("Same instance? " + (singleton1 == singleton2));
System.out.println("Value from singleton2: " + singleton2.getValue());
}
}

Singleton Implementation Comparison

Method	Pros	Cons	Use When
Eager	Simple, thread-safe	Instance created even if not used	Resource is always needed
Lazy	Creates only when needed	Not thread-safe	Single-threaded environment
Synchronized	Thread-safe	Performance overhead	Multi-threaded but low concurrency
Double-Checked	Best performance, thread-safe	More complex	High-performance multi-threaded apps
Bill Pugh	Simple, thread-safe, efficient	-	Most general cases
Enum	Simplest, thread-safe, serialization-safe	-	Best practice for all cases

When to Use Singleton Pattern

✅ Appropriate Uses:

Configuration Management - Single source of truth for settings
Logging - All components write to same log file
Database Connection Pool - Manage limited database connections
Caching - Application-level cache
Service Locators - Central point for finding services

❌ Avoid When:

Testing - Singletons can make unit testing difficult
Global State - Can lead to hidden dependencies
Multiple Instances Needed - If you might need multiple instances later

Best Practices

Use Enum for Simplicity: EnumSingleton.INSTANCE is the easiest and safest
Consider Dependency Injection: For better testability
Make it Thread-Safe: In multi-threaded environments
Prevent Reflection Attacks: Use enum or check in constructor
Handle Serialization: Implement readResolve() if using serialization

Common Pitfalls

// ❌ DON'T: Public static field (no control)
public class BadSingleton {
public static final BadSingleton INSTANCE = new BadSingleton();
private BadSingleton() {}
}
// ❌ DON'T: Not thread-safe in multi-threaded environment
public class UnsafeSingleton {
private static UnsafeSingleton instance;
private UnsafeSingleton() {}
public static UnsafeSingleton getInstance() {
if (instance == null) { // Race condition!
instance = new UnsafeSingleton();
}
return instance;
}
}

Conclusion

The Singleton Pattern is like having only one manager for a specific job in your application:

✅ Guarantees single instance - no duplicates causing conflicts
✅ Global access point - easy to reach from anywhere
✅ Controlled initialization - created when and how you want
✅ Memory efficient - only one instance in memory

Key Takeaway: Use the Enum approach for simplicity and safety, or Bill Pugh's method for lazy initialization. Remember that while Singleton solves certain problems, it should be used judiciously as it introduces global state into your application.

It's perfect for when you truly need exactly one instance of a class to coordinate actions across your system!