What is a design pattern?
Design pattern is the code structure, programming style and thinking way to solve problems after summarizing and theorizing in a large number of practice. The design model eliminates our own thinking and exploration. The design model is like a classic chess score. In different chess games, we use different chess scores and "routines".
Classification of design patterns:
① Creation mode (5 kinds): factory method mode, abstract factory mode, singleton mode, builder mode and prototype mode.
② Structural mode (7): adapter mode, decorator mode, agent mode, appearance mode, bridge mode, combination mode and sharing mode.
③ Behavioral modes (11): strategy mode, template method mode, observer mode, iteration sub mode, responsibility chain mode, command mode, memo mode, status mode, visitor mode, mediator mode and interpreter mode,
1, What is singleton mode?
Usage Summary of singleton mode
Singleton design pattern: singleton design pattern is to ensure that there is absolutely only one instance of a class in any case and provide a global access point.
The model has three basic points:
① This class can only have one instance;
② You must create this instance yourself;
③ Provide public static methods to return internally created objects.
1. Hungry Han single instance mode
Advantages: no lock, high execution efficiency, and better user experience than lazy singleton mode
Disadvantages: class is initialized when it is loaded, which takes up memory space whether it is used or not
Recommendations:
It is suitable for scenarios with few singleton modes
If we will load the class after the program starts, the singleton implemented in hungry man mode is simple and practical;
If we are writing some tool classes, we give priority to the lazy mode, which can avoid being loaded into memory in advance and occupying system resources.
/** * Description: hungry Han style singleton mode * * @date 2021 November 11, 2012 12:53:45 PM * */ public class SingletonTest { public static void main(String[] args) { Account account01 = Account.getInstance(); Account account02 = Account.getInstance(); System.out.println("account01 Your address is:"+account01); //com.jd.exer.Account@7de26db8 System.out.println("account02 Your address is:"+account02); //com.jd.exer.Account@7de26db8 System.out.println(account01==account02); //The address value is the same: true } } //Hungry Han single case mode class Account{ //1. Constructor of privatization class private Account() { } //2. Create private static objects of internal classes private static Account instance= new Account(); //3. Provide a public static method to return the created object public static Account getInstance() { return instance; } }
Operation results:
2. Lazy singleton mode - double check lock
Compared with the single lock, the performance of the double check lock is improved, but the synchronized keyword is still used. In general, the lock must be locked. There is still a certain performance impact on the program performance, which is not optimal - > there is room for optimization
Recommendations:
If we will load the class after the program starts, the singleton implemented in hungry man mode is simple and practical;
If we are writing some tool classes, we give priority to the lazy mode, which can avoid being loaded into memory in advance and occupying system resources.
/** * Description: lazy singleton mode - double check lock * * @date 2021 November 11, 2012 12:53:45 PM * */ public class SingletonTest01 { public static void main(String[] args) { Order order01 = Order.getInstance(); Order order02 = Order.getInstance(); System.out.println("account01 Your address is:"+order01); System.out.println("account02 Your address is:"+order02); System.out.println(order01==order02); //The address value is the same: true } } //Lazy singleton mode - double check lock class Order{ //1. Constructor of privatization class private Order() { } //2. Create private static objects of internal classes private static Order instance = null; //3. Declare the uninitialized current class object, provide public static methods, and return the created object public static Order getInstance() { if(instance == null) { instance = new Order(); } return instance; } }
Operation results: