设计模式3：单例模式梳理

单例模式为什么要使用懒加载？

1. 在开发中，如果某个实例的创建需要消耗很多系统资源，那么我们通常会使用惰性加载机制(懒加载），也就是只有当使用到这个实例的时候才会创建这个实例。简单的说，对象创建了，迟迟没有用到，是一种浪费，懒加载的目的是为了节省内存。
2. 如果单例类的构造函数中，调用了其他静态方法，可能会导致不必要逻辑提前执行。安全起见，还是在使用时创建。

• 饿汉模式

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

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

• 懒汉模式（线程不安全）

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

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

• 懒汉模式（线程安全）

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

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

• 双重检查模式（DCL)

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

这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了过滤不必要的同步，第二次是在singleton等于null的情况下才创建实例。

在这里用到了volatile关键字，不了解volatile关键字的可以查看Java多线程（三）volatile域这篇文章。使用volatile的目的是为了解决DCL失效。

在这里使用volatile会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。

DCL优点是资源利用率高，第一次执行getInstance时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。

在《java并发编程实践》一书建议用静态内部类单例模式来替代DCL。

• 静态内部类单例模式

public class Singleton { 
    private Singleton(){
    }
      public static Singleton getInstance(){  
        return SingletonHolder.sInstance;  
    }  
    private static class SingletonHolder {  
        private static final Singleton sInstance = new Singleton();  
    }  
} 

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

似乎静态内部类看起来已经是最完美的方法了，其实不是，可能还存在反射攻击或者反序列化攻击。

• 枚举单例

  在effective java（这本书真的很棒）中说道，最佳的单例实现模式就是枚举模式。利用枚举的特性，让JVM来帮我们保证线程安全和单一实例的问题。除此之外，写法还特别简单。

public enum Singleton {

    INSTANCE;

    public void doSomething() {
        System.out.println("doSomething");
    }

}
//调用方法
public class Main {

    public static void main(String[] args) {
        Singleton.INSTANCE.doSomething();
    }

}

• 使用容器实现单例

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

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

刘望舒大神：单例模式的7种写法
java静态内部类的加载时机