剑指offer——单例设计模式

单例模式特点：

• 单例类只能有一个实例
• 单例类必须自己创建自己的唯一实例
• 单例类必须给所有其他对象提供这一实例

饿汉式

• 饿汉式单例模式:饿汉就是类一旦加载,就把单例初始化完成，保证getInstance时，单例已经存在
• 饿汉式在类创建的同时就已经创建好了一个静态的对象供系统使用，天生就是线程安全的

class SingletonH{
    private SingletonH(){}
    private static final SingletonH single = new SingletonH();
    // 静态工厂方法
    public static SingletonH getInstance(){
        return single;
    }
}

懒汉式

• 懒汉式单例模式:只有当调用getInstance时,才回去初始化这个单例
• Singleton通过构造方法限定为private避免了类在外部被实例化

class SingletonL {
    private SingletonL(){}
    private static SingletonL single = null;
    //静态工厂方法
    public static SingletonL getInstance(){
        if(single == null){
            single = new SingletonL();
        }
        return single;
    }

懒汉式——线程安全改进

/*
     * 考虑线程安全1. 在getInstance方法上加同步
     * 在方法调用上加入同步，尽管此时线程安全了，但是每次都要同步，会影响性能，只有在第一次调用时需要同步 */
    public static synchronized SingletonL getInstance(){
        if(single == null){
            single = new SingletonL();
        }
        return single;
    }
   
    /* 2.双重检查锁定
    两次null检查，确保了只有在第一次调用实例的时候才会做同步，避免了每次都同步的性能消耗*/
    public static SingletonL getInstance(){
        if(single==null){
            synchronized(SingletonL.class){
                if(single==null){
                    single = SingletonL();
                }
            }
        }
        return single;
    }
     
    /* 3.静态内部类实现
    利用classloader机制保证初始化时只有一个线程 */
        public class SingletonL{
            private static class LazyHolder{
                private static final SingletonL Instance = new SingletonL();
            }
            private SingletonL(){}
            public static final SingletonL getInstance(){
                return LazyHolder.Instance;
            }
        }