Singleton design pattern concept
It is to take certain methods to ensure that in the entire software system, there can only be one object instance for a certain class, and that class only provides one method to obtain its object instance. If we want to makeA class can only produce one object in a virtual machine, First, we must set the access permissions of the class constructor to private, so that the new operator cannot be used to generate the class object outside the class, but the object of the class can still be generated inside the class. Because the class object cannot be obtained at the beginning of the outside of the class, a static method of the class can only be called to return the object created inside the class. The static method can only access static member variables in the class, so the variables pointing to the object generated inside the class must also be defined as static.
Hungry Man Style
class Singleton {
// 1.Privatization constructor
private Singleton() {
}
// 2. Provide an instance of the current class internally
// 4. This instance must also be static
private static Singleton single = new Singleton();
// 3. Provide a public static method to return the object of the current class; it exists from beginning to end in memory
public static Singleton getInstance() {
return single;
}
}Case:
public static void main(String[] args) {
User user1 = ();
(user1);
User user2 = ();
(user2);
}
class User{
//1. Privatization constructor
private User() {
}
//2. Provide an instance of the current class internally, and this instance must also be static.
private static User user = new User();
//3. Provide a public static method to return the object of the current class; it exists from beginning to end in memory
public static User getUser() {
return user;
}
}
//The result is the same, that is, the same object
@6d6f6e28
@6d6f6e28The static variable is initialized when the class is loaded. At this time, there will be no problem that multiple thread objects access the object. The virtual machine is guaranteed to only load the class once, and there will definitely be no concurrency problems. There is no need to use the synchronized keyword.
Existing problem: If you just load this class and do not need to call getUser, it will cause waste of resources.
Summary: thread-safe, non-lazy loading, high efficiency, waste of resources
Lazy style
Delayed object creation
Method 1: Normal creation
public class Singleton {
//Private construction method
private Singleton() {}
//Create an object of this class in the member position
private static Singleton instance;
// Provide static methods to obtain the object
public static Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}If it is a multi-threaded environment, the above code will have thread safety problems.
Method 2: Method locking
class Singleton {
// 1.Privatization constructor
private Singleton() {
}
// 2. Provide an instance of the current class internally
// 4. This instance must also be static
private static Singleton instance;
// 3. Provide a public static method to return the object of the current class
public static synchronized Singleton getInstance() {//Note the multi-threading situation
if(instance== null) {
instance= new Singleton();
}
return instance;
}
}The above use of synchronization method will cause the thread that acquires the instance to wait for locks, which will affect the system performance and fail to fully perform the system performance. You can use synchronization code blocks to solve the problem.
Method 3: Double check lock
forgetInstance()Methods, most operations are read operations, and read operations are thread-safe, so we don’t have to let each thread hold a lock to call the method. We need to adjust the timing of the lock. This also creates a new implementation mode: double check lock mode
public class Singleton {
//Private construction method
private Singleton() {}
private volatile static Singleton instance;
// Provide static methods to obtain the object
public static Singleton getInstance() {
//The first time judgment is that if the instance is not null, the lock grab stage will not enter, and the instance will be returned directly
if(instance == null) { // ①
synchronized () {
//After grab the lock, determine whether it is null again?
if(instance == null) {
instance = new Singleton();// ②
}
}
}
return instance;
}
}Why do I judge twice instance==null
The first judgment is before the code block, and the second time is after entering the code block. I believe that the second judgment is known that multiple threads are blocked in front of the code block and wait for the lock to be released. After entering the code block, the latest instance value must be obtained. If it is empty, the object will be created.
So why do we need to make the first judgment? The first judgment plays an optimization role? Assuming that if the instance is no longer empty, then there will still be threads blocking in front of the code block waiting for further judgment without the first judgment. Therefore, if it is not empty, if there is the first judgment, there is no need to enter the code block for judgment, and there is no need to wait for the lock anymore and return directly.
Why add volatile?
-
To prevent instructions from being reordered, adding volatile to private variables is mainly to prevent instructions reordering when executed at ②, that is, when "instance = new Singleton()" is executed. This line of code seems to be just a process of creating an object, but its actual execution is divided into the following 3 steps:
- Create memory space.
- Initialize the object Singleton in memory space.
- Assign the memory address to the instance object (if this step is performed, instance does not equal null).
Just imagine, if volatile is not added, thread A may execute instructions to reorder when executing to ② of the above code, and rearrange the execution orders that were originally 1, 2, and 3 into 1, 3, and 2. However, in special cases, after thread A has completed step 3, if thread B executes to the ① of the above code, it is determined that the instance object is no longer null, but thread A has not instantiated the object at this time, then thread B will get an instantiated "half" object, which leads to an error in the program execution. This is why you need to add volatile to private variables.
-
Optimization effect: Synchronized blocks will only be synchronized to the main memory after execution. For example, the instance has just been created and is not empty, but the synchronized block has not yet jumped out. At this time, there are 10,000 threads calling the method. If there is no volatile, the instance is still empty in the main memory. These 10,000 threads still have to pass the first judgment and wait before entering the code block. It is precisely with the volatile. Once the instance changes, it will be synchronized to the main memory. Even if there is no synchronized block, the instance is still synchronized to the main memory. If the first judgment is not passed, it will avoid the newly added 10,000 threads entering to fight for the lock.
Summary: thread-safe, lazy loading, and high efficiency.
Static inner class (delayed initialization placeholder class)
In the static inner class singleton pattern, instances are created by inner classes. Since the JVM does not load the static inner class during the loading of the external class, it will only be loaded when the properties/methods of the inner class are called, and its static properties are initialized. Static properties arestaticModification is guaranteed to be instantiated only once, and the instantiation order is strictly guaranteed.
public class Singleton {
private Singleton() {
}
private static class SingletonHolder{
private static final Singleton Instance = new Singleton();
}
public static Singleton getInstance(){
return ;
}
}
INSTANCE will not be initialized when the Singleton class is loaded for the first time. Only when getInstance is called for the first time, the virtual machine loads SingletonHolder and initializes INSTANCE. This not only ensures thread safety, but also ensures the uniqueness of the Singleton class.
The static internal singleton pattern is an excellent singleton pattern and is a relatively commonly used singleton pattern in open source projects. Without any locks added, security is ensured under multi-threading, and there is no performance impact or waste of space.
Summary: thread-safe, lazy loading, and high efficiency.
enumerate
The singleton mode of the enumeration class is a highly recommended singleton implementation mode because the enumeration type is thread-safe and will only be loaded once. The designer fully utilizes this feature of enumeration to implement the singleton mode. The writing of enumeration is very simple, and the enumeration type is the only singleton implementation mode in the singleton implementation used that will not be destroyed.
public enum Singleton {
INSTANCE;
}
It provides a serialization mechanism to ensure thread safety and absolutely prevent multiple instantiations, even when facing complex serialization or reflection attacks.
The enumeration method is a hungry man-style method, which will waste resources
Summary: thread-safe, non-lazy loading, and high efficiency.
Comparison of several ways
| Way | advantage | shortcoming |
|---|---|---|
| Hungry Man Style | Thread safe and efficient | Non-lazy loading, waste of resources |
| Lazy synchronized method | Thread safe, lazy loading | Inefficient |
| Lazy double detection | Thread safe, lazy loading, high efficiency | none |
| Static inner class | Thread safe, lazy loading, high efficiency | none |
| enumerate | Thread safe and efficient | Non-lazy loading, waste of resources |
Runtime class
The Runtime class is the singleton design pattern used.
public class Runtime {
private static Runtime currentRuntime = new Runtime();
/**
* Returns the runtime object associated with the current Java application.
* Most of the methods of class <code>Runtime</code> are instance
* methods and must be invoked with respect to the current runtime object.
*
* @return the <code>Runtime</code> object associated with the current
* Java application.
*/
public static Runtime getRuntime() {
return currentRuntime;
}
/** Don't let anyone else instantiate this class */
private Runtime() {}
...
}
It can be seen that the Runtime class uses the Hungry (static attribute) method to implement the singleton mode.
Previous recommendations
- "SpringBoot" EasyExcel implements the import and export of millions of data
- "SpringBoot" The most complete SpringBoot commentary in history
- Detailed explanation of Spring Framework IoC Core
- A long article of ten thousand words will take you to explore all the expansion points in Spring
- How to implement a general interface current limiting, heavy-weight and anti-shake mechanism
- A long article of ten thousand words will take you into the underlying data structure of Redis
- Analysis of the most comprehensive principle of volatile keyword