Best Practices and Performance Optimization for the Singleton Pattern in PHP

Best Practices for Singleton Pattern

Private Constructor

When using the Singleton pattern, declare the class constructor as private to prevent direct instantiation; the instance can only be obtained via a static method.

Provide a static method to retrieve the instance

To guarantee a single instance, a static method checks whether the instance already exists and creates it if not.

Store the instance in a static property

The instance is kept in a static property so that any call to the static method returns the same object.

Code example:

class Singleton {
    private static $instance;

    private function __construct() {
        // private constructor
    }

    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

Performance Optimization Techniques for Singleton Pattern

Lazy Instantiation

By default the instance is created on the first call to getInstance(); lazy instantiation defers creation until it is actually needed, avoiding unnecessary work at application startup.

Code example:

class Singleton {
    private static $instance = null;

    private function __construct() {
        // private constructor
    }

    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    public static function createInstance() {
        if (self::$instance === null) {
            self::$instance = new self();
        }
    }
}

In this example a createInstance() method is added to explicitly create the instance when required.

Serialization and Deserialization

When a singleton needs to be stored and later restored, implement the Serializable interface and define __wakeup() to ensure the same instance is returned after deserialization.

Code example:

class Singleton implements Serializable {
    private static $instance = null;

    private function __construct() {
        // private constructor
    }

    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    public function serialize() {
        return serialize(self::$instance);
    }

    public function unserialize($data) {
        self::$instance = unserialize($data);
    }
}

Proper use of these practices and optimizations makes the Singleton pattern concise, efficient, and avoids performance pitfalls, while allowing developers to choose the most suitable approach for their specific requirements.