The singleton pattern is a cliche , Here is a summary of the implementation of the singleton pattern .

 

classification

* Lazy man model
* The model of the hungry man
* IoDH technology - The combination of lazy man mode and hungry man mode
Strengths and weaknesses

* Lazy man model
* The model of the hungry man
* IoDH technology - The combination of lazy man mode and hungry man mode
 

 

classification

Lazy man model

 
  Lazy mode is a technique that does not load until the singleton pattern needs to be used . An important point of singleton pattern , To ensure the correctness of multithreading operation . to this end , There are many ways to ensure thread safety in different lazy man modes .

   synchronized It can ensure the thread safety of the method , The specific method is to use sychronized Methods of modification and sychronized
There are two ways to modify the code block .

 

synchronized Method modified singleton model
package mode; /** * Created by szh on 2020/6/28. * * @author szh */ public
class SingletonOne { private static SingletonOne singletonOne = null; private
SingletonOne() { } public synchronized static SingletonOne getInstance(){
if(singletonOne == null){ singletonOne = new SingletonOne(); } return
singletonOne; } public static void main(String[] args) {
SingletonOne.getInstance(); System.out.println("------------------------"); } }
    There are some problems with the above code , Every call getInstance() The thread locking judgment is needed , In multithreading and high concurrency access environment , The system performance will be greatly reduced .

 

synchronized Singleton pattern of code block modification

  in the light of synchronized Modification method , It can reduce the granularity of the lock , Reduce to code block level , Here is the code :
package mode; /** * Created by szh on 2020/6/28. * * @author szh */ public
class SingletonTwo { private static volatile SingletonTwo singletonTwo = null;
private SingletonTwo() { System.out.println("init"); } public static
SingletonTwo getInstance() { if (singletonTwo == null) { synchronized
(SingletonTwo.class) { if (singletonTwo == null) { singletonTwo = new
SingletonTwo(); } } } return singletonTwo; } public static void main(String[]
args) { SingletonTwo.getInstance();
System.out.println("======================="); } }
* volatile Modifying static member variables
      There's a little bit of attention , Need to use  volatile modification Static member variable , Double check failure caused by code optimization . But it also needs attention ,volatile Keywords will be masked
Java Some code optimization of virtual machine lock , It may lead to low system operation efficiency . therefore , Using double check locks to implement singleton mode is not a perfect way .

 

 

The model of the hungry man

The model of the hungry man , You can ensure that the class instantiates itself when it is loaded , You don't have to think about multithreading .

Here is the code
package mode; /** * Created by szh on 2020/6/29. */ public class
SingletonThree { private static SingletonThree singletonThree = new
SingletonThree(); private SingletonThree(){ System.out.println("init"); }
public static SingletonThree getInstance(){ return singletonThree; } public
static void main(String[] args){ SingletonThree.getInstance();
System.out.println("-----------------------------"); } }
    There are also some problems in the model of starvation , The above code solves the problem of thread safety , But every time you call getInstance()
All the time, we need to make thread locking judgment , In multithreading and high concurrency access environment , The system performance will be greatly reduced .

 

 

IoDH technology - The combination of lazy man mode and hungry man mode
package mode; /** * Created by szh on 2020/6/29. */ public class SingletonFour
{ private SingletonFour(){ System.out.println("init"); } private static class
SingletonFourInner{ private final static SingletonFour instance = new
SingletonFour(); } private static SingletonFour getInstance(){ return
SingletonFourInner.instance; } public static void main(String[] args){
SingletonFour.getInstance();
System.out.println("----------------------------"); } }
analysis :

  Static singleton objects do not act as Singleton Directly instantiate member variables of , Therefore, the class is not instantiated when it is loaded Sinleton.

  Only the first call getInstance() The inner class is loaded when , from Java Virtual machine ensures thread safety , Ensure that the member variable can only be initialized once .

 

 

 

 

Strengths and weaknesses

*
Lazy man model

advantage : Class is loaded only when it is used

inferiority :1) Complex code is needed to ensure thread safety

           2) Even if thread safety is ensured , Efficiency is not the highest

 

*
The model of the hungry man

advantage : The code is simple , There is no need to consider multithreading security

inferiority : Generate instances when a class is not in use , Worst performance

 

*
IoDH technology - The combination of lazy man mode and hungry man mode

advantage : Highest performance

inferiority : It has language characteristics ,Java Other languages are not supported

Technology
©2019-2020 Toolsou All rights reserved,
SQL Server Database Glossary CSS Animation effect dedecms Website is hacked How to solve hijacking to other websites Count the number of letters (java Language implementation )Java Basics ( Three ) String In depth analysis The difference between static method and non static method And storage location Django Personal blog building tutorial --- Time classified archiving Keras Save and load model (JSON+HDF5)hive Summary of processing methods for a large number of small files Website mobile phone number capture method