Thread safe singleton mode

The so-called single example , Just some classes , There can only be one object

When an object is created , First, you need to open up space for this object , Then call the constructor to initialize this object . However, in singleton mode , This process can only occur once , In order to achieve this goal , We need to meet the following Two conditions ：

(1) Let only one object exist in memory , This object needs Class , meanwhile Use static modification （static Decorated variables will be placed in the global area ）               

(2) To prevent other objects of this class from appearing outside the class , We're going to put various constructors Put it in private in （ If the default construction 、 There are parametric structures 、 Copy structure is not used , have access to delete Ban ）

---

Catalog

One 、 Two cases of singleton mode

Two 、 Singleton mode of lazy way

1、 Create objects within classes （ Demand one ）

 2、 Constructor privatize or disable constructor （ Requirement 2 ）

3、 Provide external interfaces for obtaining objects

  3、 ... and 、 Singleton mode test

  Four 、 expand ： Starving model （ Brief introduction ）

---

One 、 Two cases of singleton mode

On the basis of the above , Since it is creating objects , When should it be created ？？ There are two situations , One is the way of hungry men , One is the lazy way .

- Starving Han style ： Wash the bowl immediately , Convenient for cooking in the back . The object is created when the program starts running

- The lazy way ： free from restraint , Don't cook until you need it . When objects are needed , Then take the initiative to create

Two 、 Singleton mode of lazy way

Let's take a singleton class as an example , This class uses the lazy way in singleton mode , That is, wait until you want to use objects before creating objects , Let's implement it in sequence according to the above two conditions .

1、 Create objects within classes （ Demand one ）

The first is to create a unique object , And use static modification . The only object is inside the class , Outside the class, it is inevitable that you cannot obtain it in the following two ways

Sington sig;                    //  error 
Sington* sig = new Sington();    //  error 

Use this object externally , It must be obtained directly or indirectly through classes , Since you want to get through classes , Then you need to add static To modify

static The decorated member function should be initialized outside the class , The initialization method is similar to that of class member functions outside the class

 Variable type   Class name :: Variable name  =  A variable's value 

 

 2、 Constructor privatize or disable constructor （ Requirement 2 ）

The above step just creates the only object we want , So how to prevent the outside world from creating objects ？？

The answer is ： Put the constructor in private in , Or disable some constructors

==》 When an object is created in a class , You can call private Constructor in ; But if the object is created outside the class ,public The corresponding constructor cannot be found in , At this point, an error will be reported

Why not ： Suppose we use the only object we get sig To create other objects , In the memory Sington Class will have more than one object , This violates the principle of singleton , So we need to disable the copy constructor

Sington sig1(sig);        // copy constructor 

3、 Provide external interfaces for obtaining objects

Because the created object is placed in private Medium , Cannot access directly outside the class , So we need to provide an interface for out of class access , Original version as follows ：

But when multiple threads access this interface at the same time , There is a thread safety problem at this time , We need to protect sig This critical resource , So lock critical resources , The lock used must also be static Embellished

Now when a thread finally applies for a lock , But go in and have a look , Find out sig It has been initialized by other threads , Applying for a lock is superfluous , So we best Before applying for a lock , Add another judgment , First judge whether it is empty , Re apply for .

  3、 ... and 、 Singleton mode test

We create in the main thread 5 Threads , every other 1s Print the address of the currently obtained object once , And threads ID

  The test results are as follows ：

 

  Four 、 expand ： Starving model （ Brief introduction ）

Hungry man mode is created when the program starts running , The difference lies in the way the object is declared .

No * No. means to open up on the stack , At this time, the object will be allocated space when it is created

  In the interface function , There is no need to judge whether it is empty , Just go back

  Return value plus & The reason is that Prevent implicit calls to copy constructors