Java中几种常见的单例模式写法

1、饿汉式

package com.hughzhao.seekbardemo.single;

/**
 * create by hugh
 * on 2020/4/14
 */
public class Singleton {
    private static Singleton instance= new Singleton();
    private Singleton(){
    }
    public static Singleton getInstance(){
        return instance;
    }
}

这种方式在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。 这种方式基于类加载机制避免了多线程的同步问题，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到懒加载的效果。

2、懒汉式(线程不安全)

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

懒汉模式申明了一个静态对象，在用户第一次调用时初始化，虽然节约了资源，但第一次加载时需要实例化，反映稍慢一些，而且在多线程不能正常工作。

3、懒汉式(线程安全)

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

这种写法能够在多线程中很好的工作，但是每次调用getInstance方法时都需要进行同步，造成不必要的同步开销，而且大部分时候我们是用不到同步的，所以不建议用这种模式。

4、懒汉式（双重检查模式Dcl）

package com.hughzhao.seekbardemo.single;

/**
 * create by hugh
 * on 2020/4/14
 */
public class Singleton {

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

在这里使用volatile会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。 DCL优点是资源利用率高，第一次执行getInstance时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。

5、静态内部类

package com.hughzhao.seekbardemo.single;

/**
 * create by hugh
 * on 2020/4/14
 */
public class Singleton {
    private Singleton(){
    }
    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
    private static class SingletonHolder{
        private static final Singleton instance= new Singleton();
    }
}

第一次加载Singleton类时并不会初始化sInstance，只有第一次调用getInstance方法时虚拟机加载SingletonHolder 并初始化sInstance ，这样不仅能确保线程安全也能保证Singleton类的唯一性，所以推荐使用静态内部类单例模式。

6、枚举单例

public enum Singleton {  
     INSTANCE;  
     public void doSomeThing() {  
     }  
 } 

枚举单例的优点就是简单，但是大部分应用开发很少用枚举，可读性并不是很高，不建议用。

7、使用容器

public class SingletonManager { 
　　private static Map<String, Object> objMap = new HashMap<String,Object>();
　　private Singleton() { 
　　}
　　public static void registerService(String key, Object instance) {
　　　　if (!objMap.containsKey(key) ) {
　　　　　　objMap.put(key, instance) ;
　　　　}
　　}
　　public static Object getService(String key) {
　　　　return objMap.get(key) ;
　　}
}

用SingletonManager 将多种的单例类统一管理，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

总结

不同的写法，有不同的优缺点，至于用哪种，取决于你的项目。