Singleton pattern in PHP - Deep Dive

Overview - Singleton pattern

What is it?

The Singleton pattern is a way to make sure a class has only one object created during the whole program. It gives a single point to get that object from anywhere in the code. This helps control shared resources or settings. It is like having one manager who handles a task instead of many managers doing the same job.

Why it matters

Without the Singleton pattern, many parts of a program might create their own copies of an object, causing confusion and errors. For example, if multiple database connections are opened unnecessarily, it wastes resources and can cause conflicts. Singleton ensures there is only one shared instance, making the program more efficient and easier to manage.

Where it fits

Before learning Singleton, you should understand classes and objects in PHP. After Singleton, you can learn about other design patterns like Factory or Dependency Injection that help organize code better.

Mental Model

Core Idea

Singleton means only one instance of a class exists and everyone uses that same instance.

Think of it like...

Imagine a building with one main entrance door that everyone must use to get inside. This door controls who enters and ensures there is only one way in and out.

┌───────────────┐
│ Singleton     │
│   Class       │
│ ┌───────────┐ │
│ │ Instance  │◄───── Everyone uses this one
│ └───────────┘ │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Classes and Objects

Concept: Learn what classes and objects are in PHP.

value = $val; } } $obj = new Example(5); echo $obj->value; // prints 5 ?>

Result

5

Knowing how to create and use objects is essential before controlling how many objects exist.

2

Foundation

Static Properties and Methods

Concept: Learn how static properties and methods belong to the class, not instances.

Result

1

Static members allow shared data or behavior across all uses of a class, which is key for Singleton.

3

Intermediate

Creating a Singleton Class

Concept: Use a private constructor and a static method to control instance creation.

Result

Same instance

Controlling object creation with a private constructor and static method ensures only one instance exists.

4

Intermediate

Preventing Cloning and Serialization

Concept: Stop creating new instances by cloning or unserializing the Singleton.

Result

Fatal error: Call to private method

Blocking cloning and unserialization protects the Singleton from accidental duplication.

5

Intermediate

Using Singleton for Shared Resources

Concept: Apply Singleton to manage shared resources like database connections.

connection = new PDO('sqlite::memory:'); } public static function getInstance() { if (self::$instance === null) { self::$instance = new Database(); } return self::$instance; } public function getConnection() { return $this->connection; } } $db1 = Database::getInstance(); $db2 = Database::getInstance(); echo ($db1 === $db2) ? 'Same DB instance' : 'Different DB instances'; ?>

Result

Same DB instance

Singleton ensures all parts of the program share the same database connection, saving resources.

6

Advanced

Thread Safety and Singleton

🤔Before reading on: do you think Singleton is always safe in multi-threaded environments? Commit to yes or no.

Concept: Understand that Singleton can have issues in multi-threaded or concurrent contexts without extra care.

In PHP, most scripts run single-threaded, so Singleton is safe. But in multi-threaded or asynchronous environments, two threads might create separate instances if they check for instance existence at the same time. To fix this, locking or other synchronization is needed.

Result

Without synchronization, multiple instances can be created in parallel threads.

Knowing Singleton's limits in concurrency prevents subtle bugs in advanced applications.

7

Expert

Singleton Anti-Patterns and Alternatives

🤔Quick: Is Singleton always the best way to share data in large applications? Commit yes or no.

Concept: Learn when Singleton causes problems and what better patterns exist.

Singleton can hide dependencies, making code hard to test and maintain. Overusing it leads to tight coupling. Alternatives like Dependency Injection provide more flexible and testable designs. Use Singleton sparingly and prefer explicit passing of shared objects.

Result

Better code structure and easier testing by avoiding Singleton misuse.

Understanding Singleton's drawbacks helps write cleaner, more maintainable code.

Under the Hood

Singleton works by storing a static reference to its single instance inside the class. When getInstance() is called, it checks if the instance exists. If not, it creates one and saves it. The constructor is private to prevent outside code from making new objects. This ensures only one object lives in memory for that class.

Why designed this way?

Singleton was designed to control access to shared resources and avoid multiple costly or conflicting instances. The private constructor and static instance pattern enforce this rule. Alternatives like global variables were error-prone and hard to manage, so Singleton provides a cleaner, object-oriented solution.

┌───────────────┐
│ Singleton     │
│   Class       │
│ ┌───────────┐ │
│ │ static    │ │
│ │ instance  │ │
│ └────┬──────┘ │
│      │        │
│ getInstance()│
│      │        │
│  ┌───▼─────┐  │
│  │ if null │  │
│  │ create  │  │
│  │ instance│  │
│  └─────────┘  │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does calling getInstance() multiple times create new objects each time? Commit yes or no.

Common Belief: Each call to getInstance() creates a new object.

Reality: getInstance() returns the same single object every time after the first creation.

Why it matters: Believing this causes confusion about resource usage and leads to unnecessary object creation.

Quick: Can you create a Singleton object by using the 'new' keyword outside the class? Commit yes or no.

Common Belief: You can create Singleton objects with 'new' like any other class.

Reality: The constructor is private, so 'new' outside the class causes an error.

Why it matters: Trying to create multiple instances breaks the Singleton pattern and causes runtime errors.

Quick: Is Singleton always safe in multi-threaded programs? Commit yes or no.

Common Belief: Singleton is always safe and creates only one instance even in multi-threaded code.

Reality: Without synchronization, multiple instances can be created in parallel threads.

Why it matters: Ignoring this can cause hard-to-find bugs in concurrent applications.

Quick: Does Singleton make code easier to test and maintain? Commit yes or no.

Common Belief: Singleton always improves code quality and testability.

Reality: Singleton can hide dependencies and make testing harder by introducing global state.

Why it matters: Misusing Singleton leads to tightly coupled code that is difficult to change or test.

Expert Zone

1

Singleton instances can cause hidden dependencies that make code harder to refactor or test.

2

Lazy initialization delays object creation until needed, saving resources but adding complexity.

3

In PHP, serialization and cloning must be blocked to fully protect Singleton uniqueness.

When NOT to use

Avoid Singleton when you need multiple instances or want clear dependency management. Use Dependency Injection or Service Containers instead for better flexibility and testability.

Production Patterns

Singleton is often used for database connections, logging, or configuration managers in real applications. Professionals combine it with Dependency Injection containers to control lifecycle and testing.

Connections

Dependency Injection

Alternative pattern that manages shared objects explicitly instead of hiding them.

Knowing Singleton helps understand why Dependency Injection improves code clarity and testability by avoiding hidden global state.

Global Variables

Singleton is a controlled, object-oriented replacement for global variables.

Understanding Singleton clarifies how to avoid the pitfalls of global variables while still sharing data.

Operating System Mutexes

Both Singleton and mutexes control access to a single resource to avoid conflicts.

Recognizing this connection shows how Singleton enforces single access like a mutex prevents simultaneous resource use.

Common Pitfalls

#1 Trying to create multiple Singleton objects using 'new'.

Wrong approach:

Correct approach:

Root cause:

Misunderstanding that the constructor is private and that 'new' is blocked to enforce single instance.

#2 Not blocking cloning allows duplicate Singleton instances.

Wrong approach:

Correct approach:

Root cause:

Forgetting to make __clone() private to prevent duplication.

#3 Using Singleton everywhere without considering testability.

Wrong approach:

Correct approach:

Root cause:

Not realizing Singleton hides dependencies and makes unit testing difficult.

Key Takeaways

Singleton ensures only one instance of a class exists and provides a global access point to it.

It uses a private constructor and a static method to control instance creation and sharing.

Blocking cloning and unserialization is necessary to fully protect the single instance.

Singleton is useful for shared resources but can cause hidden dependencies and testing challenges.

Alternatives like Dependency Injection often provide better flexibility and maintainability.

Practice

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

easy

A. To ensure only one instance of a class is created

B. To allow multiple instances of a class

C. To inherit properties from multiple classes

D. To create objects without a constructor

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 purpose

   Only To ensure only one instance of a class is created correctly states this purpose; others describe different concepts.

3. Final Answer:

   To ensure only one instance of a class is created -> Option A

4. Quick Check:

   Singleton = single instance only [OK]

Hint: Singleton means one and only one instance [OK]

Common Mistakes:

• Thinking Singleton allows multiple instances
• Confusing Singleton with inheritance
• Believing Singleton removes constructors

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

easy

A. public static $instance;

B. private static $instance;

C. protected $instance;

D. static $instance;

Solution

1. Step 1: Identify visibility for Singleton instance

   The instance variable must be private static to restrict access and keep one shared instance.

2. Step 2: Check options for correct syntax and visibility

   private static $instance; uses private static, which is correct. Others either lack visibility or static keyword.

3. Final Answer:

   private static $instance; -> Option B

4. Quick Check:

   Singleton instance is private static [OK]

Hint: Singleton instance must be private and static [OK]

Common Mistakes:

• Using public instead of private
• Omitting static keyword
• Using protected instead of private

3. What will be the output of the following PHP code?

class Singleton {
    private static ?Singleton $instance = null;
    public int $value;
    private function __construct() { $this->value = 10; }
    public static function getInstance(): Singleton {
        if (self::$instance === null) {
            self::$instance = new Singleton();
        }
        return self::$instance;
    }
}

$obj1 = Singleton::getInstance();
$obj2 = Singleton::getInstance();
$obj2->value = 20;
echo $obj1->value;

medium

A. 10

B. null

C. 20

D. Error

Solution

1. Step 1: Understand Singleton instance sharing

   Both $obj1 and $obj2 refer to the same Singleton instance.

2. Step 2: Trace value changes

   Changing $obj2->value to 20 affects $obj1->value because they are the same object.

3. Final Answer:

   20 -> Option C

4. Quick Check:

   Singleton shares one object, so value = 20 [OK]

Hint: Singleton returns same object, changes reflect everywhere [OK]

Common Mistakes:

• Assuming separate objects for each getInstance call
• Expecting original value 10 after change
• Thinking code causes error

4. Identify the error in this Singleton implementation:

class Singleton {
    private static $instance;
    private function __construct() {}
    public static function getInstance() {
        if (!isset(self::$instance)) {
            return new Singleton();
        }
        return self::$instance;
    }
}

medium

A. No error, code is correct

B. Constructor should be public

C. Static variable should be public

D. getInstance() does not assign the new object to static instance

Solution

1. Step 1: Check getInstance method logic

   The method creates a new Singleton but does not save it to self::$instance.

2. Step 2: Identify missing assignment

   Without assigning, every call returns a new object, breaking Singleton pattern.

3. Final Answer:

   getInstance() does not assign the new object to static instance -> Option D

4. Quick Check:

   Missing assignment breaks Singleton [OK]

Hint: Always assign new instance to static variable in getInstance [OK]

Common Mistakes:

• Making constructor public
• Not assigning instance in getInstance
• Changing static variable visibility incorrectly

5. You want to extend a Singleton class in PHP but ensure the child class also follows Singleton rules independently. Which approach is best?

hard

A. Use separate static instance variables in parent and child classes

B. Share the parent's static instance variable in the child class

C. Make constructor public in child class

D. Avoid inheritance and duplicate Singleton code

Solution

1. Step 1: Understand Singleton inheritance challenge

   Parent and child classes must maintain separate single instances to avoid conflicts.

2. Step 2: Use separate static variables

   Each class having its own static instance variable ensures independent Singleton behavior.

3. Final Answer:

   Use separate static instance variables in parent and child classes -> Option A

4. Quick Check:

   Separate static instances keep Singleton independent [OK]

Hint: Each class needs its own static instance variable [OK]

Common Mistakes:

• Sharing static instance causes one instance for both classes
• Making constructor public breaks Singleton
• Avoiding inheritance unnecessarily