Singleton pattern in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use the Singleton pattern?

Which of the following best explains the main purpose of the Singleton pattern in system design?

A To allow multiple instances of a class to be created with different configurations.

B To ensure a class has only one instance and provide a global point of access to it.

C To separate the interface from the implementation of a class.

D To enable objects to be created without specifying the exact class.

💡 Hint

Think about controlling the number of instances of a class.

The Singleton pattern restricts a class to a single instance and provides a global access point to that instance, ensuring controlled access and consistent state.

❓ Architecture

intermediate

Singleton implementation in a multithreaded environment

Which design approach correctly implements a thread-safe Singleton pattern to avoid multiple instances in a multithreaded system?

A Use eager initialization by creating the instance at class loading time, ensuring thread safety.

B Use lazy initialization without synchronization, creating the instance when first requested.

C Create a new instance every time the getInstance method is called.

D Use a static variable without any synchronization or initialization.

💡 Hint

Consider thread safety and when the instance is created.

Eager initialization creates the instance when the class loads, which is inherently thread-safe because the instance is created before any thread accesses it.

❓ scaling

advanced

Scaling Singleton in distributed systems

What is the main challenge when using the Singleton pattern in a distributed system with multiple servers?

A Using Singleton to create multiple instances for load balancing.

B Allowing each server to create its own independent Singleton instance.

C Avoiding the use of Singleton to reduce memory usage on each server.

D Ensuring that only one instance exists across all servers simultaneously.

💡 Hint

Think about instance uniqueness across multiple machines.

In distributed systems, the Singleton pattern must ensure a single instance across all servers, which is difficult because each server runs independently.

❓ tradeoff

advanced

Trade-offs of Singleton pattern usage

Which of the following is a common trade-off when using the Singleton pattern in system design?

A It guarantees high scalability in distributed environments.

B It simplifies testing by allowing easy instance replacement.

C It can introduce global state, making unit testing and debugging harder.

D It eliminates the need for synchronization in multithreaded code.

💡 Hint

Consider how global state affects testing and debugging.

Singleton introduces global state which can make unit testing difficult because tests may affect each other through shared state.

❓ component

expert

Singleton instance count in a complex system

Consider a system with three modules: A, B, and C. Each module uses the Singleton pattern to access a Logger class. The system runs on two servers. How many Logger instances exist at runtime?

A Two instances, one per server, shared by all modules on that server.

B One instance shared across all modules and servers.

C Three instances, one per module, shared across servers.

D Six instances, one per module per server.

💡 Hint

Think about Singleton scope and server boundaries.

Singleton ensures one instance per process. Since there are two servers (processes), each has its own Singleton instance shared by all modules on that server.

Practice

1. What is the main purpose of the Singleton pattern in system design?

easy

A. To ensure only one instance of a class exists throughout the application

B. To allow multiple instances of a class with different states

C. To create a new instance every time it is requested

D. To inherit properties from multiple classes

Solution

1. Step 1: Understand Singleton pattern goal

   The Singleton pattern is designed to restrict a class to a single instance.

2. Step 2: Compare options with Singleton definition

   Only To ensure only one instance of a class exists throughout the application matches the purpose of Singleton by ensuring one instance exists.

3. Final Answer:

   To ensure only one instance of a class exists throughout the application -> Option A

4. Quick Check:

   Singleton = single instance [OK]

Hint: Singleton means one instance only, no duplicates [OK]

Common Mistakes:

• Thinking Singleton allows multiple instances
• Confusing Singleton with factory pattern
• Assuming Singleton creates new instances each call

2. Which of the following is the correct way to declare a Singleton instance method in a class?

easy

A. public static getInstance() { ... }

B. public void getInstance() { ... }

C. private static getInstance() { ... }

D. static getInstance() { ... }

Solution

1. Step 1: Identify Singleton instance method requirements

   The method to get the Singleton instance must be static and publicly accessible.

2. Step 2: Analyze options for correct access and static usage

   public static getInstance() { ... } is public and static, which is correct. public void getInstance() { ... } is not static, private static getInstance() { ... } is private, static getInstance() { ... } misses access modifier.

3. Final Answer:

   public static getInstance() { ... } -> Option A

4. Quick Check:

   Singleton instance method = public static [OK]

Hint: Singleton instance method must be public and static [OK]

Common Mistakes:

• Making getInstance() private or non-static
• Omitting access modifier
• Using void return type instead of instance

3. Given the following Singleton code snippet, what will be the output?

class Logger {
  static instance = null;
  constructor() {}
  static getInstance() {
    if (this.instance === null) {
      this.instance = new Logger();
    }
    return this.instance;
  }
}
const log1 = Logger.getInstance();
const log2 = Logger.getInstance();
console.log(log1 === log2);

medium

A. undefined

B. true

C. false

D. Error

Solution

1. Step 1: Understand Singleton instance creation

   The first call to getInstance() creates the instance; the second returns the same instance.

2. Step 2: Compare references of log1 and log2

   Both variables point to the same instance, so strict equality returns true.

3. Final Answer:

   true -> Option B

4. Quick Check:

   Same instance check = true [OK]

Hint: Singleton returns same object reference every time [OK]

Common Mistakes:

• Assuming new instance created on each call
• Confusing equality with object content
• Expecting false due to separate variables

4. Identify the error in this Singleton implementation:

class Config {
  static instance;
  constructor() {}
  static getInstance() {
    if (!instance) {
      instance = new Config();
    }
    return instance;
  }
}

medium

A. No error, code is correct

B. Constructor should be public, not private

C. Missing 'this.' before 'instance' inside getInstance method

D. Static keyword is missing before getInstance method

Solution

1. Step 1: Check static variable access inside static method

   Static variables must be accessed with 'this.' prefix inside static methods.

2. Step 2: Identify missing 'this.' usage

   The code uses 'instance' instead of 'this.instance', causing a reference error.

3. Final Answer:

   Missing 'this.' before 'instance' inside getInstance method -> Option C

4. Quick Check:

   Static variable access requires 'this.' [OK]

Hint: Use 'this.' to access static variables inside static methods [OK]

Common Mistakes:

• Ignoring 'this.' prefix for static variables
• Changing constructor visibility incorrectly
• Assuming static keyword missing on method

5. You need to design a logging system using the Singleton pattern that supports multi-threaded access safely. Which approach best ensures thread safety while maintaining Singleton behavior?

hard

A. Use a global variable outside the class to store the instance

B. Create a new instance every time getInstance() is called

C. Make the constructor public and static

D. Use double-checked locking with a private static volatile instance variable

Solution

1. Step 1: Understand thread safety in Singleton

   In multi-threaded environments, multiple threads may create multiple instances if not synchronized.

2. Step 2: Evaluate options for thread-safe Singleton

   Double-checked locking with a volatile static instance ensures only one instance is created safely.

3. Final Answer:

   Use double-checked locking with a private static volatile instance variable -> Option D

4. Quick Check:

   Thread-safe Singleton = double-checked locking [OK]

Hint: Double-checked locking ensures thread-safe Singleton [OK]

Common Mistakes:

• Ignoring thread safety in Singleton
• Making constructor public defeats Singleton
• Using global variables breaks encapsulation