[设计模式] - 单例模式（Singleton Pattern）全方式解析

单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。

饿汉式单例

饿汉式单例是在类加载时就立即初始化，并且创建单例对象。在线程还没有出现前就实例化，不存在线程安全问题。

public class HungrySingleton {

    private static final HungrySingleton hugrySingleton = new HungrySingleton();

    private HungrySingleton(){}

    private static HungrySingleton getInstance(){
        return hugrySingleton;
    }

}

使用静态代码块实现

public class HungryStaticSingleton {

    private static final HungryStaticSingleton hungryStaticSingleton;

    static {
        hungryStaticSingleton = new HungryStaticSingleton();
    }

    private HungryStaticSingleton(){}

    private static HungryStaticSingleton getInstance(){
        return hungryStaticSingleton;
    }
}

饿汉式单例

饿汉式单例是在被外部类调用的时候内部类才会加载。

public class LazySimpleSingleton {
    
    private LazySimpleSingleton(){}
    
    private static LazySimpleSingleton lazySimpleSingleton = null;
    
    public static LazySimpleSingleton getInstance(){
        
        if (lazySimpleSingleton == null){
            lazySimpleSingleton = new LazySimpleSingleton(); 
        }
        
        return lazySimpleSingleton;
    }
}

通过运行上面代码，我们会发现一个很大的问题 — 线程不安全
这时我们可以在getInstance方法上使用synchronized关键字

public class LazySimpleSingleton {
    
    private LazySimpleSingleton(){}
    
    private static LazySimpleSingleton lazySimpleSingleton = null;
    
    public synchronized static LazySimpleSingleton getInstance(){
        
        if (lazySimpleSingleton == null){
            lazySimpleSingleton = new LazySimpleSingleton(); 
        }
        
        return lazySimpleSingleton;
    }
}

这时我们的安全问题便解决了，但是由于使用加锁，在线程数量比较大的情况下，cpu分配压力上升，会导致大批的线程阻塞。为了兼顾安全性和程序性能，我们可以使用双重检查锁的单例模式。

public class LazyDoubleCheckSingleton {

    private volatile static LazyDoubleCheckSingleton singleton = null;

    private LazyDoubleCheckSingleton(){}

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

    }
}

当第一个线程调用getInstance时，第二个线程依然可以调用。当执行到synchronized时就会上锁，而第二个就会进入monitor状态。此时只是在getInstance（）中阻塞，而不是整个类。
虽然进步了，但依然还是存在锁。只要存在锁就会对性能有一定的影响。所以，有了静态内部类的方式。

public class LazyInnerClassSingleton {

    private LazyInnerClassSingleton(){}

    public static final LazyInnerClassSingleton getInstance(){

        return LazyHolder.LAZY_INNER_CLASS_SINGLETON;
    }

    private static class LazyHolder{

        private static final LazyInnerClassSingleton LAZY_INNER_CLASS_SINGLETON
                = new LazyInnerClassSingleton();
    }
}

这种方式既兼顾了内存浪费也兼顾了上锁的性能问题，内部类在方法调用之前就初始化了，避免了线程安全的问题。但是我们依然可以使用反射和序列化的手段让他生成不同的单例

注册时单例

1. 枚举式单例

public enum  EnumSingleton {

    /**
     * 单例
     */
    INSTANCE;
    private Object data;
    private Object getData(){
        return data;
    }
    private void setData(Object data){
        this.data = data;
    }
    
    private static EnumSingleton getInstance(){
        return INSTANCE;
    }
    
}

《Effective java》推荐单例模式，他会自动转化在静态代码块中对INSTANCE赋值，属于饿汉单例的实现。同时他又可以保证不可被反射生成和序列化
2. 容器缓存单例

public class ContainerSingleton {

    private ContainerSingleton(){}

    private static Map<String,Object> ioc = new ConcurrentHashMap<>();

    public static Object getBean(String className){

        synchronized (ioc) {
            if (!ioc.containsKey(className)) {
                Object object = null;

                try {
                    object = Class.forName(className).newInstance();
                    ioc.put(className, object);
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
                return object;
            } else {
                return ioc.get(className);
            }
        }

    }

}

容器式写法适用于创建的实例特别多的情况，便于管理。但它是非线程安全的。