What happens if you not making constructor private?

Multiple instances can be created externally, breaking singleton Fix: Declare constructor as private or protected

What happens if you omitting synchronization in lazy initialization?

Multiple threads may create multiple instances concurrently Fix: Add synchronization or use thread-safe constructs

What happens if you synchronizing entire getinstance() method unnecessarily?

Performance degrades due to locking on every call Fix: Use double-checked locking to minimize synchronization

Interview Prepoop-design-patternsmediumAmazonGoogleMicrosoftFlipkartSwiggyRazorpayPhonePeCRED

Singleton Pattern - Thread Safety, Double-Checked Locking & Lazy Init

Choose your preparation mode3 modes available

Solution Trace

🎯

mediumOOPAmazonGoogleMicrosoft

Imagine a logging system where multiple parts of an application need to write logs, but all must use the same logger instance to avoid conflicts and ensure consistency.

💡 The Singleton pattern ensures only one instance of a class exists and provides a global access point. Beginners often struggle with thread safety and lazy initialization, which are crucial for real-world applications where multiple threads may try to create instances simultaneously.

📋

Problem Statement

Design and implement the Singleton pattern ensuring thread safety and lazy initialization. Your implementation should prevent multiple instances from being created in a multithreaded environment, optimize performance by minimizing synchronization overhead, and optionally use language-specific features like enums for simplicity and safety.

The singleton instance must be lazily initialized (created only when first requested).The implementation must be thread-safe to prevent multiple instances in concurrent scenarios.Avoid unnecessary synchronization after the instance is initialized.Use language idioms where applicable (e.g., enum in Java).

💡

Example

Input"Multiple threads call getInstance() concurrently"

OutputAll threads receive the same singleton instance

Despite concurrent calls, only one instance is created and shared.

Multiple threads call getInstance() simultaneously → only one instance created
No calls to getInstance() → instance is never created (lazy initialization)
Repeated calls to getInstance() after initialization → no synchronization overhead
Singleton class is subclassed or cloned → should prevent multiple instances

⚠️

Common Mistakes

Not making constructor private

Multiple instances can be created externally, breaking singleton

✅ Declare constructor as private or protected

Omitting synchronization in lazy initialization

Multiple threads may create multiple instances concurrently

✅ Add synchronization or use thread-safe constructs

Synchronizing entire getInstance() method unnecessarily

Performance degrades due to locking on every call

✅ Use double-checked locking to minimize synchronization

Not using volatile keyword with double-checked locking in Java

Instruction reordering can cause partially constructed instance to be visible

✅ Declare instance as volatile

Allowing cloning or serialization to create new instances

Singleton property is violated by multiple instances

✅ Override clone() and readResolve() methods to prevent this

🧠

Basic Singleton with Eager Initialization

💡 This approach introduces the Singleton concept simply by creating the instance at class load time. It is easy to understand but lacks lazy initialization and may waste resources if the instance is never used.

Intuition

Create the singleton instance when the class is loaded, so it is always available and thread-safe by default due to class loading guarantees.

Algorithm

Declare a private static final instance of the class.
Make the constructor private to prevent external instantiation.
Provide a public static method to return the instance.
Return the pre-created instance directly.

💡 The main challenge is understanding why the instance is created upfront and how private constructors enforce single instantiation.

</>

Code

class Singleton:
    _instance = object()  # Eagerly created dummy instance

    def __new__(cls):
        # Always return the same instance
        return cls._instance

# Driver code to test
if __name__ == '__main__':
    s1 = Singleton()
    s2 = Singleton()
    print(s1 is s2)  # True

Line Notes

class Singleton:Defines the Singleton class to encapsulate the pattern

_instance = object() # Eagerly created dummy instanceEagerly creates a single instance at class load time

def __new__(cls):Overrides __new__ to control instance creation

return cls._instanceAlways returns the same pre-created instance

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

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2); // true
    }
}

Line Notes

private static final Singleton instance = new Singleton();Eagerly creates the singleton instance at class load time

private Singleton() {}Prevents external instantiation

public static Singleton getInstance() {Provides global access to the instance

return instance;Returns the pre-created singleton instance

#include <iostream>

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}
public:
    static Singleton* getInstance() {
        // Directly return the eagerly initialized instance
        return instance;
    }
};

// Eager initialization
Singleton* Singleton::instance = new Singleton();

int main() {
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();
    std::cout << (s1 == s2) << std::endl; // 1 (true)
    return 0;
}

Line Notes

static Singleton* instance;Declares static pointer to hold singleton instance

Singleton() {}Private constructor to prevent external instantiation

static Singleton* getInstance() {Returns the singleton instance without checks

Singleton* Singleton::instance = new Singleton();Eagerly initializes the singleton instance

class Singleton {
  constructor() {
    if (Singleton.instance) {
      return Singleton.instance;
    }
    Singleton.instance = this;
  }
}

// Test
const s1 = new Singleton();
const s2 = new Singleton();
console.log(s1 === s2); // true

Line Notes

constructor() {Controls instance creation in JavaScript

if (Singleton.instance) {Returns existing instance if already created

Singleton.instance = this;Assigns the first created instance

console.log(s1 === s2);Confirms both variables point to the same instance

⏱

Complexity

TimeO(1)

SpaceO(1)

Instance is created once at class load, so getInstance() is constant time and space.

💡 For any number of calls, the instance is reused, so performance is optimal but initialization is not lazy.

Interview Verdict: Accepted

This approach is thread-safe due to class loading guarantees but wastes resources if the instance is never used.

Approach	Time	Space	Stack Risk	Reconstruct	Use In Interview
1. Basic Eager Initialization	`O(1)`	`O(1)`	No	No	Explain concept; not suitable if lazy init required
2. Lazy Initialization with Synchronized Method	`O(1) but synchronized every call`	`O(1)`	No	No	Show thread safety but mention performance drawback
3. Double-Checked Locking with Volatile	`O(1) amortized, minimal locking`	`O(1)`	No	No	Preferred approach for thread-safe lazy initialization
4. Enum Singleton (Java only)	`O(1)`	`O(1)`	No	No	Best practice in Java; mention if language allows

Practice

(1/5)

1. When a class inherits from multiple classes that have a method with the same name, describe the step-by-step process the Method Resolution Order (MRO) uses to determine which method is called.

easy

A. MRO uses a linearization algorithm that merges the order of parents and their ancestors to find the method.

B. MRO searches the first parent class fully before moving to the next parent class.

C. MRO always calls the method from the last parent class listed in the inheritance.

D. MRO randomly picks the method from any parent class that defines it.

2. Given the following code snippet, what will be printed when executing the last two lines?

from abc import ABC, abstractmethod

class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

class CreditCardStrategy(PaymentStrategy):
    def pay(self, amount):
        print(f"Processing credit card payment of ${amount}")

class UPIStrategy(PaymentStrategy):
    def pay(self, amount):
        print(f"Processing UPI payment of ${amount}")

class PaymentStrategyFactory:
    @staticmethod
    def get_strategy(method):
        if method == 'CreditCard':
            return CreditCardStrategy()
        elif method == 'UPI':
            return UPIStrategy()
        else:
            raise ValueError('Invalid payment method')

class PaymentProcessor:
    def __init__(self, strategy: PaymentStrategy):
        self.strategy = strategy

    def pay(self, amount):
        self.strategy.pay(amount)

processor = PaymentProcessor(PaymentStrategyFactory.get_strategy('UPI'))
processor.pay(100)

easy

A. Raises ValueError: Invalid payment method

B. Processing credit card payment of $100

C. Processing net banking payment of $100

D. Processing UPI payment of $100

4. Identify the bug in the following Python code implementing deep copy for the Profile class:

import copy

class Profile:
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores

    def __deepcopy__(self, memo):
        new_name = self.name  # Bug here
        new_scores = copy.deepcopy(self.scores, memo)
        return Profile(new_name, new_scores)

original = Profile('Alice', [10, 20])
copy_obj = copy.deepcopy(original)
copy_obj.scores.append(30)
print(original.scores)

medium

A. Line assigning new_name = self.name does not deepcopy the name string

B. Line assigning new_scores = copy.deepcopy(self.scores, memo) incorrectly copies scores

C. The __init__ method does not initialize scores properly

D. The return statement returns a new Profile instead of modifying self

Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard

Intuition

Algorithm

Intuition

Algorithm

Intuition

Algorithm

Intuition

Algorithm

How to Present

Time Allocation

What the Interviewer Tests

Common Follow-ups

When to Use

Signature Phrases

NOT This Pattern When

Similar Problems

Practice

Solution

Step 1: Understand naive search

Step 2: Recognize MRO linearization

Step 3: Eliminate incorrect options

Final Answer:

Quick Check:

Solution

Step 1: Trace strategy selection

Step 2: Trace payment method call

Final Answer:

Quick Check:

Solution

Step 1: Analyze statement A

Step 2: Validate other statements

Step 3: Why A is incorrect

Final Answer:

Quick Check:

Solution

Step 1: Examine __deepcopy__ method

Step 2: Understand impact

Final Answer:

Quick Check:

Solution

Step 1: Understand reuse implications

Step 2: Identify correct approach

Step 3: Confirm undo/redo stack integrity

Final Answer:

Quick Check:

Ready to prove it?

Step 1: Examine deepcopy method