Blog

Introduction

Welcome back to our series on low-level design patterns for tech interview preparation! In this installment, we’ll explore the Singleton pattern, one of the simplest yet most controversial design patterns. By the end of this article, you’ll have a solid understanding of the Singleton pattern and be ready to discuss its implementation, use cases, and potential drawbacks in your next tech interview. As always, we’ll use Java for our code examples, given its popularity in many tech interviews.

What is the Singleton Design Pattern?

The Singleton pattern is a creational design pattern that ensures a class has only one instance and provides a global point of access to that instance. It’s useful when exactly one object is needed to coordinate actions across the system.

Key Characteristics

1. Private constructor to prevent instantiation from other classes.
2. Private static variable of its own class that holds the only instance of the class.
3. Public static method that returns the instance of the class, creating it if it doesn’t exist.

Basic Implementation

Let’s start with a basic implementation of the Singleton pattern:

public class Singleton {
    private static Singleton instance;
    
    private Singleton() {
        // Private constructor to prevent instantiation
    }
    
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    
    public void showMessage() {
        System.out.println("Hello, I am a singleton!");
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        singleton.showMessage();
    }
}

This basic implementation, however, is not thread-safe. In a multi-threaded environment, multiple threads could create separate instances of the Singleton class.

Thread-Safe Implementation

Here’s a thread-safe implementation using double-checked locking:

public class Singleton {
private static volatile Singleton instance;

private Singleton() {
    // Private constructor to prevent instantiation
}

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

public void showMessage() {
    System.out.println("Hello, I am a thread-safe singleton!");
}

The volatile keyword ensures that multiple threads handle the instance variable correctly when it is being initialized to the Singleton instance.

Eager Initialization

If the Singleton is not resource-intensive, we can use eager initialization:

public class Singleton {
private static final Singleton instance = new Singleton();

private Singleton() {
    // Private constructor to prevent instantiation
}

public static Singleton getInstance() {
    return instance;
}

public void showMessage() {
    System.out.println("Hello, I am an eagerly initialized singleton!");
}

This approach is thread-safe without the use of synchronization.

Real-World Example: Logger

Let’s implement a simple logger as a Singleton:

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class Logger {
    private static Logger instance;
    private PrintWriter writer;
    
    private Logger() {
        try {
            FileWriter fw = new FileWriter("application.log");
            writer = new PrintWriter(fw, true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static synchronized Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }
    
    public void log(String message) {
        writer.println(message);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Logger logger = Logger.getInstance();
        logger.log("Application started");
        
        // Do some work
        
        logger.log("Application finished");
    }
}

This Logger ensures that all parts of the application log to the same file, and we don’t create multiple file handles unnecessarily.

Key Takeaways for Your Low-Level Design Interview

1. Global Access Point: Singleton provides a global point of access to the instance.
2. Lazy Initialization: The instance is typically created only when it’s first needed.
3. Thread Safety: Properly implemented Singletons are thread-safe.
4. Restricted Instantiation: Singleton prevents other objects from instantiating their own copies of the Singleton object.

Interview Tips

When discussing the Singleton pattern in a low-level design interview:

1. Explain the basic concept and implementation of the Singleton pattern.
2. Discuss thread-safety issues and how to resolve them (e.g., double-checked locking, eager initialization).
3. Highlight real-world use cases, such as managing a connection pool, caches, thread pools, or configuration settings.
4. Be prepared to implement a simple example in Java, like the logger we discussed.
5. Discuss potential drawbacks of the Singleton pattern:
   • It can make unit testing difficult.
   • It violates the Single Responsibility Principle.
   • It’s often overused or misused.
6. Mention alternatives to Singleton, such as dependency injection.
7. Discuss how Singleton relates to other design principles and patterns, showing your broader understanding of software design.

Conclusion

The Singleton pattern, while simple in concept, requires careful consideration in implementation, especially in multi-threaded environments. It’s a powerful tool when used appropriately but can lead to issues if overused or misapplied. By understanding the Singleton pattern, its implementations, use cases, and potential pitfalls, you’ll demonstrate your ability to make informed low-level design decisions in your next tech interview.

Remember to practice implementing this pattern and be ready to discuss its pros and cons in the context of larger system designs. Good luck with your low-level design interview preparation!