单例模式几种常见写法

经典写法（线程不安全）

/**
 * @author hall_p
 * @date 2020-05-19 12:36
 * @desc 经典单例，线程不安全；多线程下 会破坏掉单例；
 */
public class ClassicSingleton {

    private static ClassicSingleton classicSingleton;

    private ClassicSingleton(){

    }

    public static ClassicSingleton getInstance(){
        if(classicSingleton == null){
            classicSingleton = new ClassicSingleton();
        }
        return classicSingleton;
    }
}

经典写法加锁

/**
 * @author hall_p
 * @date 2020-07-04 17:28
 * @desc 线程安全 缓加载 但是效率低
 */
public class SafeSingleton {
    private static SafeSingleton safeSingleton;

    private SafeSingleton() {
    }

    public static synchronized SafeSingleton getInstance(){
        if(safeSingleton == null){
            safeSingleton = new SafeSingleton();
        }
        return safeSingleton;
    }
}

双重检查

/**
 * @author hall_p
 * @date 2020-05-19 12:41
 * @desc 线程安全的单例模式；改进classic 延迟初始化
 */
public class ThreadSafeSingleton {

    private volatile static ThreadSafeSingleton threadSafeSingleton;

    private ThreadSafeSingleton(){

    }

    public static ThreadSafeSingleton getInstance(){
        if(threadSafeSingleton == null){ 
            synchronized (ThreadSafeSingleton.class){
                if(threadSafeSingleton == null){
                    threadSafeSingleton = new ThreadSafeSingleton();
                }
            }
        }
        return threadSafeSingleton;
    }
}

基于类的初始化

public class InstanceFactory {
    private static class InstanceHolder{
        private static InstanceFactory instance = new InstanceFactory();
    }

    private InstanceFactory(){

    }

    public static InstanceFactory getInstance(){
        return InstanceHolder.instance;
    }
}

/**
 * @author hall_p
 * @date 2020-05-19 12:38
 * @desc 随类加载的单例模式；线程安全，获取速度快，但是加载慢；
 */
public class EagerlySingleton {

    private static EagerlySingleton eagerlySingleton = new EagerlySingleton();

    private EagerlySingleton(){

    }

    public static EagerlySingleton getInstance(){
        return eagerlySingleton;
    }
}

错误的双重检查

/**
 * @author
 * @date 
 * @desc 双重检查锁定来实现延迟初始化的示例代码 
 */
public class DoubleCheckedLocking {
    private static DoubleCheckedLocking doubleCheckedLocking;

    private DoubleCheckedLocking(){}

    public static DoubleCheckedLocking getInstance(){
        if(doubleCheckedLocking == null){ //1
            synchronized (DoubleCheckedLocking.class){ //2
                if(doubleCheckedLocking == null){//3
                    doubleCheckedLocking = new DoubleCheckedLocking();
                }
            }
        }

        return doubleCheckedLocking;
    } //代码读取到doubleCheckedLocking instance不为null时，instance引用的对象有可能还没有完成初始化。
}

线程B在1处
线程A在1处 得到锁；
进入代码块
开始进行初始化
	分配对象的内存空间
	设置instance指向内存空间
线程B在1处执行，判断instance不为null；实际上此时对象还没有完成初始化；对instance的使用就会出现异常
线程A初始化对象

分配对象的内存空间 //1
初始化对象 //2
设置instance指向内存空间//3
 2和3之间存在着重排序的可能性就是问题的根源。