Singleton Pattern

# CHAPTER 6

Singleton Pattern #

1. Introduction #

2. Learning Objectives #

• Define the intent and structure of the Singleton Pattern.

• Implement a basic Singleton using a private constructor and a static method.

• Understand the concept of "Lazy Initialization."

• Analyze the thread-safety issues of Singletons in multi-threaded environments.

• Discuss why the Singleton is often considered an "Anti-Pattern" in modern testing.

3. The Singleton Concept #

1. 1. Ensure a class has only one instance. (Stop people from using new).

1. 2. Provide a global point of access to that instance. (Let anyone use it easily).

4. Implementation Steps #

1. 1. Make the Constructor Private: If __construct() is private, nobody outside the class can instantiate it.

1. 2. Create a Static Property: Create a private static variable inside the class to hold the single instance.

1. 3. Create a Static Getter: Create a public static method (usually called getInstance()). This method checks if the static property is empty. If it is, it creates the object (from *inside* the class) and saves it. If it is not empty, it simply returns the saved object.

5. Lazy Initialization #

6. UML Diagram #

---------------------------------
|          Singleton            |
---------------------------------
| - instance: Singleton         |  <-- (Static variable holding itself)
---------------------------------
| - Singleton()                 |  <-- (Private constructor)
| + getInstance(): Singleton    |  <-- (Public static access point)
---------------------------------

7. Code Example (PHP) #

<?php

class Logger {
    // 1. Hold the single instance
    private static $instance = null;

    // 2. Prevent instantiation with 'new'
    private function __construct() {
        echo "Logger initialized.\n";
    }

    // Prevent cloning (a way to bypass 'new')
    private function __clone() {}

    // 3. The global access point
    public static function getInstance() {
        if (self::$instance === null) {
            // Lazy Initialization
            self::$instance = new Logger();
        }
        return self::$instance;
    }

    public function log($message) {
        echo "[LOG]: " . $message . "\n";
    }
}

// Usage:
// $logger = new Logger(); // ERROR: Call to private constructor!

$log1 = Logger::getInstance(); // Outputs: Logger initialized.
$log1->log("First message.");

$log2 = Logger::getInstance(); // (No initialization output, returns existing instance)
$log2->log("Second message.");

// Prove they are the exact same object in memory
var_dump($log1 === $log2); // bool(true)
?>

8. Best Practices (Thread Safety) #

9. Common Mistakes (The Anti-Pattern Debate) #

• Global State: Singletons are essentially glorified global variables. They hide dependencies. If a Checkout class secretly calls Logger::getInstance() deep inside its code, you can't easily see that dependency from the outside.

• Testing Nightmare: Unit testing a Singleton is incredibly difficult. Because the state is global, if Test A modifies the database Singleton, Test B might fail because it is using the exact same mutated instance.

• *The Modern Alternative:* Dependency Injection (DI) containers. Modern frameworks (Laravel, Spring) create a single object and *inject* it where needed, achieving the same goal without the global state issues.

10. Mini Project: Build a Configuration Manager #

1. 1. Create a ConfigManager Singleton class.

1. 2. In its private constructor, load an array of fake settings (e.g., ['theme' => 'dark', 'lang' => 'en']).

1. 3. Add a getSetting($key) method.

1. 4. From three different random functions in your script, call ConfigManager::getInstance()->getSetting('theme') to prove they all share the same configuration memory.

11. Practice Exercises #

1. 1. Explain exactly how making a constructor private physically enforces the first rule of the Singleton pattern.

1. 2. Define "Lazy Initialization." Why is it highly beneficial for heavy objects like Database Connections?

12. MCQs with Answers #

13. Interview Questions #

• Q: Write a thread-safe Singleton pattern in your preferred programming language on the whiteboard. Explain how you prevent a race condition during initialization.

• Q: A junior developer uses the clone keyword to duplicate your Singleton object, successfully bypassing the private constructor. How do you defensively program your Singleton class to prevent cloning?

• Q: Compare the Singleton pattern to simply defining a massive global variable file. What structural advantages does the Singleton offer?

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #