public class Singleton { private static Singleton instance; private Singleton() { } public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; }}Copy the code

public class Singleton { private static Singleton instance = new Singleton(); private Singleton() { } public static Singleton getInstance() { return instance; }}Copy the code

[html]
view plain
copy
print
?

1. public class Singleton {  
2.     private static Singleton instance = null;  
3.   
4.     static {  
5.         instance = new Singleton();  
6.     }  
7.   
8.     private Singleton() {  
9.     }  
10.   
11.     public static Singleton getInstance() {  
12.         return instance;  
13.     }  
14. }  

public class Singleton { private static Singleton instance = null; static { instance = new Singleton(); } private Singleton() { } public static Singleton getInstance() { return instance; }}Copy the code

public class Singleton {
    private volatile static Singleton instance = null;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}Copy the code

Instance = new Singleton() : volatile = new Singleton()

[java]
view plain
copy
print
?

1. inst = allocat();   // Step 1: Allocate memory  
2. constructor(inst);  // Step 2: Execute the constructor  
3. instance = inst;    // Set the instance object to the allocated memory space.  

inst = allocat(); Constructor (inst); Instance = inst; // Set the instance object to the allocated memory space.Copy the code

This is where the Java memory model comes in.

Because the Java compiler allows the processor to execute out of order, the order of the second and third steps is not guaranteed. If instance is called by another thread when the third step is completed and the second step is not executed, it will be judged as null and used directly. However, the constructor has not been executed and the member variables and other fields have not been initialized. This is the PROBLEM of DCL failure, and it is very difficult to repeat.

Write operations on volatile variables are not allowed to be out of order with previous reads and writes. Read operations on volatile variables are not allowed to be out of order with subsequent reads and writes.

When a thread wants to use a volatile variable in shared memory, it reads directly from main memory, rather than using a copy in its own local memory. When a thread writes to a volatile variable, it flushers the value of the shared variable to shared memory.

The use of volatile may affect performance somewhat, but this is a small sacrifice for the stability of the program. The above code can also be optimized:

[html]
view plain
copy
print
?

1. public class Singleton {  
2.     private volatile static Singleton instance = null;  
3.   
4.     public static Singleton getInstance() {  
5.         Singleton inst = instance; // Create temporary variables
6.         if (inst == null) {  
7.             synchronized (Singleton.class) {  
8.                 inst = instance;  
9.                 if (inst == null) {  
10.                     inst = new Singleton();  
11.                 }  
12.             }  
13.         }  
14. return inst; // Returns a temporary variable
15.     }  
16.   
17.     private Singleton() {}  
18. }  

public class Singleton { private volatile static Singleton instance = null; public static Singleton getInstance() { Singleton inst = instance; Synchronized (Singleton. Class) {synchronized (Singleton. Class) {synchronized (Singleton. if (inst == null) { inst = new Singleton(); } } } return inst; Private Singleton() {}}Copy the code

We added a temporary variable so that, except for the first initialization, subsequent accesses would reduce access to instance and never improve performance to any degree.

public enum Singleton {
    INSTANCE;
}Copy the code

The simplicity of writing is one of the most important features of enumerations. The most important is that the default enumeration instance is created thread-safe and is in any case a singleton.


We use the singleton pattern so that instances of a class are unique. However, if the class is Serializable, such as when the Serializable interface is implemented, it is possible to write a singleton to disk by serializing it, and then get an instance in the city, effectively. Even if the constructor of a function is private, deserialization can create a new instance of the class in a special way, equivalent to calling the constructor of the class. Deserialization provides a special hook function with a private, instantiated readResolve() method that gives the developer control over deserialization of the object. To ensure that the singleton nature is preserved during deserialization, you can add a readResolve() method to the singleton

[html]
view plain
copy
print
?

1. private Object readResolve() throws ObjectStreamException {  
2.     return instance;  
3. }  

    private Object readResolve() throws ObjectStreamException {
        return instance;
    }Copy the code

The readResolve() method is called when deserialization reads the read object from the I/O stream, essentially replacing the object created in deserialization directly with the object returned from readResolve().

Resources: developer.51cto.com/art/201202/…

public class Singleton { private Singleton() { } public static Singleton getInstance() { return SingletonInstance.instance; } private static class SingletonInstance { private static final Singleton instance = new Singleton(); }}Copy the code

public class Singleton {
    private static Map<String, Object> instanceMap = new HashMap<String, Object>();

    private Singleton() {
    }

    public static void addInstance(String key, Object instance) {
        if (!instanceMap.containsKey(key)) {
            instanceMap.put(key, instance);
        }
    }

    public static Object getInstance(String key) {
        return instanceMap.get(key);
    }
}Copy the code

Reference connection:

Segmentfault.com/a/119000000…

www.infoq.com/cn/articles…

www.race604.com/java-double…

Mp.weixin.qq.com/s?__biz=MzA…