[Design Pattern] Application scenarios and implementation of PHP singleton pattern

Summary

What is the singleton pattern?

A class is only allowed to create one object (or instance), then this class is a singleton class. This design pattern is called the singleton design pattern, or singleton pattern for short.

Why use singleton?

1. # Handle resource access conflicts.

   For example: the function of printing logs to a file.
   

2. represents a globally unique class.
   

From a business concept, if some data should only be saved in one copy in the system, it is more suitable to design it as a singleton class. For example: unique increasing ID number generator.

Implementation method

It takes three steps to implement the singleton mode of PHP

* A static member variable used to save the class.

* To prevent object creation or cloning, __construct and __clone need to be declared private.

* A public static method to access this instance, usually getInstance

class single
{
    private static  $instance ;
    private function __construct(){}
    private function __clone(){}
    public static function getInstance() {
        if (empty(self::$instance)) {
            self::$instance = new single();
        }
        return self::$instance;
    }
}

Add a method to the singleton class to get the ID. A globally unique ID number generator appears.

class single
{
    private  $id = 0;
    private static  $instance ;
    private function __construct(){}
    private function __clone(){}
    public static function getInstance() {
        if (empty(self::$instance)) {
            self::$instance = new single();
        }
        return self::$instance;
    }
    public function getId() {
        
        return $this->id++;
        
    }
}

It’s really impeccable, so what happens in the case of multi-threading?

Implementing the only single instance of a thread

I have to mention the difference between ts and nts versions of php, nts (Non Thread Safe) single-thread construction, shared cache data between threads. ts (Thread Safe) is built with multi-threading capabilities and uses different data copies among multiple threads.

Use the ts version of php to automatically upgrade to thread-safe mode. The pthreads extension can only be installed on the ts version of php.

The last version of pthreads included in pecl is based on php7.0. The pthreads project on github has also stopped updating. If you are interested, you can only go to 7.0 to miss the history.

I installed the pthreads extension under the php-7.0.9-Win32-VC14-x64 version.

In the case of multi-threading, the scope of the singleton changes from process-only to thread-only.

require 'single.php';
class Request extends Thread {
    public $url;
    public function __construct($url) {
        $this->url = $url;
    }
    public function run() {
        echo single::getInstance()->getId();
        echo "\n";
    }
}
$chG = new Request("www.google");
$chG ->start();
$chG->join();
echo $chG->getThreadId();
echo "\n";
$chB = new Request("www.baidu");
$chB ->start();
$chB->join();
echo $chB->getThreadId();
echo "\n";

Two threads are created here, but the id starting from 0 can be obtained in both executions, indicating that the single classes in the two threads are two different singleton objects.

Summary

It takes three steps to implement PHP’s singleton mode

* A static Member variables are used to save classes.

* __construct and __clone are declared private to prevent creation or cloning.

* A static method, usually getInstance, used to access this instance.

I have never used multi-threading in PHP. It seems to be a point of no return. I don’t know what everyone thinks.

The above is the detailed content of [Design Pattern] Application scenarios and implementation of PHP singleton pattern. For more information, please follow other related articles on the PHP Chinese website!