单例模式下的双重检验锁Double Checked Locking

1. 双重检验锁

该部分内容引自维基百科。

package com.fqyuan.con_singleton;

public class SingletonClass {
    private static volatile SingletonClass INSTANCE;

    //private constructor.
    private SingletonClass() {
    }
    //static method to get the instance
    public static SingletonClass getInstance() {
        if (INSTANCE == null) { //First time check.
            synchronized (SingletonClass.class) {
                if (INSTANCE == null) { //Second time check.
                    INSTANCE = new SingletonClass();
                }
            }
        }
        return INSTANCE;
    }
}

In software engineering, double-checked locking (also known as “double-checked locking optimization”[1]) is a software design pattern used to reduce the overhead of acquiring a lock by first testing the locking criterion (the “lock hint”) without actually acquiring the lock. Only if the locking criterion check indicates that locking is required does the actual locking logic proceed.
It is typically used to reduce locking overhead when implementing “lazy initialization” in a multi-threaded environment, especially as part of the Singleton pattern. Lazy initialization avoids initializing a value until the first time it is accessed.
双重检验锁是通过首先判定是否需要加锁来降低获取锁的开销的一种软件设计模式。尤其在Java语言多线程应用中，通过懒初始化方式降低锁的开销。

2. 关于该问题的讨论

1.什么是懒初始化lazy initialization？
A：Lazy initialization avoids initializing a value until the first time it is accessed. Lazy means the instance is initialized when it is used for the first time.

懒初始化方式，是一种在第一次使用时才初始化的模式。这样可以避免大型的类的初始化带来的性能负担。

2.懒初始化的单例模式VS一般单例模式（这里有该问题讨论）。

//Example of eager initialization.
//It is initialized before it's used.
public class Singleton{
    private static Singleton INSTANCE = new Singleton();
    private Singleton(){
    }
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

对于上述代码，有人认为是lazy initialized的，理由是：
‘Your first design is actually lazy. Think about it, the instance is only created when the class is initialized; the class is only initialized when the getInstance() method is called.

看似合理：一个类在使用之前需要经历–load->link->initialization三个阶段，静态变量的初始化会在加载时完成，所以上述说法有问题。

可以看下面代码段做的验证：

package com.fqyuan.con_singleton;

class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {
        System.out.println("Eager Constructor.");
    }

    public static Singleton getInstance() {
        return INSTANCE;
    }

}
package com.fqyuan.con_singleton;

public class SingletonClass {
    private static volatile SingletonClass INSTANCE;

    // private constructor.
    private SingletonClass() {
        System.out.println("Lazy Constructor");
    }

    // static method to get the instance
    public static SingletonClass getInstance() {
        if (INSTANCE == null) { // First time check.
            synchronized (SingletonClass.class) {
                if (INSTANCE == null) { // Second time check.
                    INSTANCE = new SingletonClass();
                }
            }
        }
        return INSTANCE;
    }
}
package com.fqyuan.con_singleton;

public class Test {
    public static void main(String[] args) throws Exception {

        Class<?> cl1 = Class.forName("com.fqyuan.con_singleton.Singleton");
        Class<?> cl2 = Class.forName("com.fqyuan.con_singleton.SingletonClass");

        System.out.println(cl1.getName());
        System.out.println(cl2.getName());
        // Eager初始化会在加载类时进行；而Lazy初始化会在第一次访问时
        Singleton.getInstance();
        SingletonClass.getInstance();
    }
}

//Running result:
Eager Constructor.
com.fqyuan.con_singleton.Singleton
com.fqyuan.con_singleton.SingletonClass
Lazy Constructor

//Lazy initialization
public class Singleton{
    private static Singleton INSTANCE = null;
    private Singleton(){
    }
    public static Singleton getInstance(){
        if(INSTANCE == null)
            INSTANCE = new Singleton();
        return INSTANCE;
    }
}

3.线程安全单例模式的实现方式。

Q:为什么这里需要 Double Checked lock?
A: 参考自这里。
线程安全问题发生在单例对象还未创建时。假设此时有2个线程分别为A和B，假如至少有一个到达了‘//Second time check’位置，并发现了单例对象还未创建INSTANCE==null, 注意这2个线程并不能同时到达该位置，因为它是同步代码块。所以，要么是A要么是B到达了该位置，为了不失一般性，我们假设A先到该代码块，因为INSTANCE==null这个条件为真，所以会new一个新的实例对象，然后退出同步代码块。现在轮到B了，要记得，当时B是被A阻塞了，所以它在进入同步代码块时，首先检测INSTANCE==null这个条件是否为真，这里不成立，B就直接退出该同步区了。如果没有二次检测，则会创建2个单例对象.
package com.fqyuan.con_singleton;

public class SingletonClass {
private static volatile SingletonClass INSTANCE;

// private constructor.
private SingletonClass() {
    System.out.println("Lazy Constructor");
}

// static method to get the instance
public static SingletonClass getInstance() {
    if (INSTANCE == null) { // First time check.
        synchronized (SingletonClass.class) {
            if (INSTANCE == null) { // Second time check.
                INSTANCE = new SingletonClass();
            }
        }
    }
    return INSTANCE;
}

}

3. 其他线程安全的方式

1). Initialization on demand([here](https://en.wikipedia.org/wiki/Initialization-on-demand_holder_idiom))
public class Something {
    private Something() {}

    private static class LazyHolder {
        static final Something INSTANCE = new Something();
    }

    public static Something getInstance() {
        return LazyHolder.INSTANCE;
    }
}

2). enum方式(here)

public enum Product{
    INSTANCE;
    private int state = 0;
    pubilc void doSomething(){
        ++state;
        System.out.println("I did something for the "+ state+" time");
    }
}
public class Main{
    public static void main(String[] args){
    Product.INSTANCE.doSomething();
    }
}