五种单例模式

1. 饿汉式（线程安全，调用率高，但是，不能延迟加载。）

 public class Singleton{
            private static Singleton singleton = new Singleton ();
            private Singleton (){}
            public static Singleton getInstance(){return singletion;}
       } 

2. 懒汉式（线程安全，调用效率不高，可以延时加载。）

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

3. 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题，不建议使用）

public class Singleton {
    private volatile static Singleton singleton;

    private Singleton() {
    }

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

4. 静态内部类式（线程安全，调用效率高。但是，可以延时加载）

public class StaticInnerClassSingleton {

    private static class InnerClass {
        private static StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
    }
    public static StaticInnerClassSingleton getInstance(){
        return InnerClass.staticInnerClassSingleton;
    }
}

5. 枚举式（线程安全，调用率高，不能延时加载）

public class EnumSingleton {
    
    private EnumSingleton() {
    }
    
    private enum Singleton{
    	INSTANCE;
    	
    	private final EnumSingleton instance;

    	Singleton(){
			instance=new EnumSingleton();
		}
		public EnumSingleton getInstance() {
			return instance;
		}
    }

    public static EnumSingleton getInstance() {
        return EnumSingleton.INSTANCE.getInstance();
    }
}

如何选择

1. 单例对象占用资源少的话，且不需要延时加载，枚举式优于饿汉式
2. 单例对象占用资源大且需要延时加载，静态内部类式优于懒汉式