单例模式梳理

单例三要素
1.私有的构造函数
2.静态的对象实例
3.静态的获取对象的 方法

为了保证多线程安全，有三种解决方法

第一种：同步获取实例的方法

package com.test.single;

public class Single {
    
    private static Single instance;

    private Single() { }
    
    public static synchronized Single getInstacne() {
        if (null == instance) {
            
            instance = new Single();
        }
        return instance;
    }
    
   
}

点评：线程安全，但是性能差，每次在获取这个实例的时候都需要进行线程安全判断

第二种 双重检查

package com.test.single;

public class DoubleCheck {
    
    private volatile static DoubleCheck instance; //这里必须是volatile的，这样保证对象的可见性
    
    private DoubleCheck () {
        
    }
    
    public static DoubleCheck getInstance(){
        if (null == instance) {
            synchronized (DoubleCheck.class) { //具体这个地方的实现可以是多种多样的，也可以用LOCK
                if (null == instance) {
                    instance = new DoubleCheck();
                }
            }
        }
        return instance;
    }

}

点评：不需要每次去实例对象，在JDK1.5以前版本不能保证线程安全，存在JDK版本限制

第三种：懒汉式创建对象

package com.test.single;

public class LazySingle {
    
    private static LazySingle instance = new LazySingle();

    private LazySingle() { }
    
    public static  LazySingle getInstacne() {
        return instance;
    }
}

点评：直接在实例对象时，静态初始化，保证实例的唯一。但是在某些情况下，对象未被使用，且这个对象很大时，就会很消耗资源

对于这种懒汉式的做法还有个变种，用了一个静态内部类来保证实例的唯一

第四种：静态内部类

package com.test.single;

public class SingleInnner {
    
    private SingleInnner(){}
    
    static class InstanceHandle {
        static volatile  SingleInnner instance = new  SingleInnner();
    }
    
    public static  SingleInnner getInstacne() {
        return InstanceHandle.instance;
    }
    
}

点评：其实这种方式的出现早期是为了解决double-check的问题，其实本质上就是一个懒汉式的做法，还是在类加载时候初始化一个静态实例。玩个花哨而已，而且还变的更加复杂了，想比较第三中没有什么区别！仅仅当做参考而已！


单例中还需要注意的几个点：
1.单例的出现时为了解决在系统中只保证一个对象实例，但是使用的情况应该不多，若是太多的，就是设计存在问题！
2.若是存在多个类加载器的话，那么单例还是会失效
3.在JDK1.2中，还是会将单例对象回收，需要建立注册表
4.综合考虑性能和资源，选择合适的方案来解决多线程的问题，默认情况下，我们认为所有的场景都是多线程的！


常见单例实例场景：
线程池，缓存，注册表等！