单例模式各种实现

懒汉

public class LazyMan {
    private static LazyMan lazyMan = new LazyMan();
    private LazyMan() {
    }
    public static LazyMan getInstance() {
        return lazyMan;
    }
}

实现原理：私有构造方法，暴露获取对象接口。
缺点：浪费资源。可以通过反射来破坏单一性。

饿汉

public class HungryMan {
    private static HungryMan hungryMan;
    private HungryMan() {
    }
    public static HungryMan getInstance() {
        if(hungryMan == null ){
            synchronized (HungryMan.class){
                if(hungryMan == null ){
                    hungryMan = new HungryMan();
                }
            }
        }
        return hungryMan;
    }
}

实现原理：私有构造方法，暴露获取对象接口。使用时双层检测没有创建时创建对象。
缺点：可以通过反射来破坏单一性。并发环境下。

具体来说，创建一个对象的过程分为三步：1，分配内存空间。2：初始化。3：引用指向内存空间。
实际上执行时，不一定按照1-2-3的顺序执行。有可能会分配完空间后，执行第三步。此时hungryMan 是有指向的空间。但是空间是空的。

内部类

枚举

public class SingletonObject7 {
 
 
    private SingletonObject7(){
 
    }
 
    /**
     * 枚举类型是线程安全的，并且只会装载一次
     */
    private enum Singleton{
        INSTANCE;
 
        private final SingletonObject7 instance;
 
        Singleton(){
            instance = new SingletonObject7();
        }
 
        private SingletonObject7 getInstance(){
            return instance;
        }
    }
 
    public static SingletonObject7 getInstance(){
 
        return Singleton.INSTANCE.getInstance();
    }
}