设计模式之单例模式 Singleton实现

public class SingletonDemo1 {
    //类初始化时，立即加载这个对象（没有延时加载的优势）,，记载类时，天然的是线程安全的
    private static SingletonDemo1 instance = new SingletonDemo1(); 
    private SingletonDemo1(){
        
    };
    
    //方法没有同步，效率高
    public static SingletonDemo1 getInstance(){
        return instance;
    }
    
}

public class SingletonDemo2 {
    //类初始化时，不初始化这个对象，（延时加载，真正用到的时候再创建）
    private static SingletonDemo2 instance ; 
    private SingletonDemo2(){
        
    };
    
    //方法同步，效率低
    public static synchronized SingletonDemo2 getInstance(){
        
        
        if(instance==null){
            instance= new SingletonDemo2();
        }
        return instance;
    }
    
}

public class Singleton {
    private volatile static Singleton sSingleton;

    private Singleton() {
    }

    public static Singleton getSingleton() {
        if (sSingleton == null) {
            synchronized (Singleton.class) {
                if (sSingleton == null) {
                    sSingleton = new Singleton();
                }
            }
        }
        return sSingleton;
    }
}

public class SingletonDemo3 {
    
    private static class SingletonClassInstance{
        private static final SingletonDemo3 instance = new SingletonDemo3() ; 
    }
    
    private SingletonDemo3(){
        
    }
    
    public static SingletonDemo3 getInstance(){
        return SingletonClassInstance.instance;
    }
    
}

public enum SingletonDemo4 {
    
    //枚举元素本身就是单例对象
    INSTANCE;
    
    //添加自己需要的操作
    public void singletonOperation(){
        
    }
}

public class SingletonDemo5 {
    //类初始化时，不初始化这个对象，（延时加载，真正用到的时候再创建）
        private static SingletonDemo5 instance ; 
        private SingletonDemo5(){
            if(instance !=null){
                throw new RuntimeException();
            }
        }
        
        //方法同步，效率低
        public static synchronized SingletonDemo5 getInstance(){
            if(instance==null){
                instance= new SingletonDemo5();
            }
            return instance;
        }
        
        //反序列化时，如果定义了readResolve()，则直接返回此方法指定的对象，而不需要单独创建新的对象
        private Object readResolve(){
            return instance;
        }
}