单例模式（饿汉，懒汉，懒汉线程安全，双重校验，枚举，spring相关）

1.饿汉式

public class SingletonHungry {
    private SingletonHungry instance = new SingletonHungry();

    private SingletonHungry() {
    }

    public SingletonHungry getInstance(){
        return instance;
    }
}

2.懒汉式

public class SingletonLazy {
    private SingletonLazy() {

    }

    private SingletonLazy instance;

    public SingletonLazy getInstance(){
        if (instance == null){   //线程不安全
            return new SingletonLazy();
        }
        return instance;
    }
}

3.懒汉式线程安全

public class SingletonLazySafe {
    private SingletonLazySafe() {
    }

    private SingletonLazySafe instance;

    public synchronized SingletonLazySafe getInstance(){ //线程安全效率低
        if (instance == null){
            return new SingletonLazySafe();
        }
        return instance;
    }
}

4.双重校验锁

双重校验锁对同步方法的优化，就是加了第一个判断，让不为null的情况下，不需要进入同步锁。

public class SingletonDoubleCheck {
    private SingletonDoubleCheck() {
    }

    private static volatile SingletonDoubleCheck instance;

    public static SingletonDoubleCheck getInstance(){
        if (instance != null){
            return instance;
        }
        synchronized (SingletonDoubleCheck.class){
            if (instance != null){
                return instance;
            }
            return new SingletonDoubleCheck();
        }
    }
}

5.枚举

public enum SingletonEnum {
    INSTANCE;
}

6.Spirng。todo什么时候是饿汉什么时候是懒汉。

public class SingletonSpring {
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        synchronized (this.singletonObjects) {
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject != null){
                return singletonObject;
            }else {
                return singletonFactory.getObject();
            }
        }
    }

}

有不对请指正