JIYIK CN >

The singleton design pattern is one of the most commonly used design patterns. The singleton design pattern, just by its name, you can roughly know its meaning. Single means one; instance means instance object. So a singleton has only one instantiated object. Therefore, we can define the singleton design pattern as follows:

The singleton design pattern is used to restrict a particular object to be created only once and provide shared access to itself to the entire system.

The singleton design pattern generally only allows one instance of itself to be created, so when it is first instantiated, an object is created and stored inside itself. When the object is used next, the object will first check the storage to see if the object has been instantiated. If it already has its own instance, it returns a reference, otherwise it creates an object of its own as described above and stores it inside itself for use by requests.

The principle of the singleton design pattern can be said to be what is mentioned above, and it can be said that it is independent of the programming language. However, due to the differences in the syntax of different programming languages, the implementation of the singleton design pattern is also different. Let's take Java and PHP as examples to illustrate.

For Java, the singleton design pattern can be divided into lazy and hungry styles according to the time when the object is instantiated.

The so-called hungry singleton means that when the singleton class is loaded, it instantiates an object of itself and stores it inside itself.

The code is as follows:

public class Singleton{
         private static Singleton singleton = new Singleton();
         private Singleton(){}
         public static Singleton __Instance(){
                   return singleton;
         }       
}

From the above code, we can see that when the class starts loading, a private static variable singleton is declared, and its own object is instantiated and assigned to the variable singleton. This is the so-called hungry singleton.

The so-called lazy singleton means that it will only instantiate its own object and store it inside itself when the method that generates the instance object is called.

The code is as follows:

public class Singleton {
    private static Singleton singleton;
    private Singleton(){}
    public static synchronized Singleton __Instance(){
        if(singleton==null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

From the above code, we can see that only when the __Instance() method is called, it will first determine whether the variable singleton is empty. If it is not empty, it means that the instantiated object has been created. Otherwise, the instantiated object is created and assigned to the variable singleton.

The above is Java code. Because Java is a compiled language, it supports instantiating the object when the class is loaded.

But for PHP, PHP is an interpreted language. If the class is not loaded, it cannot instantiate the object of the class. Therefore, PHP does not support hungry singletons, which means that the following code has errors and cannot pass.

class Singleton{
         private static $singleton = new self;
         private function __construct(){}
         public static function __Instance(){
                   return self::$singleton;
         }
}

Therefore, PHP only supports lazy singletons, the code is as follows:

class Singleton{
         private static $singleton;
         private function __construct(){}
         public static function __Instance(){
                   if(!self::$singleton instanceof self){
                         self::$singleton = new self;
                   }
                   return self::$singleton;
         }       
}

The most common scenario for using the singleton design pattern is to create a database connection object. The database access object is responsible for creating a database connection instance. Whenever a specific method of the object is called, it will use the connection resource it has already created. It is well known that the cost of creating a database connection resource is very high (it takes a lot of time and resources). Therefore, when designing the code, you should create as few database connection resources as possible.

In most cases, after the data in the database is retrieved, there is no need to keep the database connection resources and they can be released. In view of this situation, it makes sense to make the database access object a singleton. Every time a new data operation requires a new database access object, the previous object will be reused, and there is no need to instantiate a new database access object to establish additional database connection resources.

Therefore, we can know that using the singleton design pattern can save memory space, avoid repeated creation and destruction of objects, improve performance, and so on.

Because the singleton design pattern is often used to connect to the database, I wrote a class for operating the database, and tried to use the singleton design pattern when designing the class.

The source code is hosted on github , and there is a brief introduction to the use of the class functions. Everyone is welcome to download it.