Design Pattern -- 单例模式

单例模式是设计模式中最常用到的一种模式,一般应用于定位管理、线程管理、文件管理、网络管理等类上面，让这些类的单一实例来处理App的各个模块逻辑等。
这里我就不多举例子了，相信大家应该都会用，我就将基本所有类型的单例实现方式列举出来，供大家参考吧。

（1）几种常见的单例模式模板

1. 饿汉单例

“饿汉”，指的是代码很早就想要初始化实例出来，于是，此形式的类实例在类编译加载在内存中的时候就初始化创建完毕。

public class Singleton{
     private static Singleton sInstance = new SingleTon();

     private Singleton() {}

     public Singleton getInstance(){
           return sInstance;
     }
}

优点：类加载时实例化对象，避免了多线程同步创建问题。
缺点：类加载时就进行初始化，即还没用到它，它就占了App进程的部分内存，造成一定的内存浪费。【没有懒加载】

2. 懒汉单例（加了synchronized，保证线程安全）

“懒汉”，相对于“饿汉”来说，就不是在编译时急着初始化了，而是在调用到类静态方法要用到一个实例时，他再初始化单例对象。

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

注意，以上的code，方法加synchronized与否，直接影响读取性能。

3. DCL 单例（双重检查锁定）

public class DCLSingleTon {

//  private static DCLSingleTon sInstance;
    private volatile static DCLSingleTon sInstance = null;
    ///考虑到 DCL失效问题：JDK1.5之前的JMM（Java内存模型）中的Cache、寄存器到主内存回写顺序的规定，上面三件事中的后面两件事的顺序无法保证。
    ///这样，如果是执行1->3->2的执行顺序，那么，在内部成员都没有被初始化的情况下，sInstance就已经被赋值为非null了，那就后面会产生错误了。
    ///于是，>=JDK1.5时，可以这样：
//  private volatile static DCLSingleTon sInstance = null;
    ///虽然这样，加载时会影响性能，但是，还是值得的。
    ///这样一来，就可以每次在主内存中读取对象了。
    
    private DCLSingleTon(){
        
    }
    
    public static DCLSingleTon getInstance(){
        
        if(sInstance== null){
            synchronized (DCLSingleTon.class) {
                if(sInstance == null){
                    sInstance = new DCLSingleTon();
                }
            }
        }
        return sInstance;
    }
}

• 优点：既能够在需要时才初始化单例【懒加载】，又能够保证线程安全，而且，单例对象初始化后的getInstance调用是不会进行同步锁的【第一次要初始化对象所以慢，第二次之后就很快】。
• 缺点：加入了volatile关键字（JDK1.5以上），保证Java编译器执行顺序，但影响了性能。【不过，这个影响很小】

4. 静态内部类单例【推荐】

public class StaticSingleTon {
    private static StaticSingleTon sInstance;
    
    private StaticSingleTon(){}
    
    public static StaticSingleTon getInstance(){
        return StaticSingleTon.sInstance;
    }
    /// 静态内部类
    private static class SingleTonHolder{
        private static final StaticSingleTon sInstance = new StaticSingleTon();
    }
}

• 特点：同样 是 只有第一次调用getInstance()时，才会加载SingleTonHolder类，也才会初始化对象。
• 解决了DCL乱序问题【不怕他会执行乱序。一定是先初始化对象，然后获取对象。】

5. 枚举单例

public enum EnumSingleTon {
    DOG,CAT;
    public void bark(){
      System.out.println(toString()+"吠了一声！");   
    }
}

然后，我们可以直接调用:

DOG.bark();
DOG.bark();
CAT.bark();
CAT.bark();

永远只存在一条狗和一只猫的实例。

• 优点：解决了对象反序列化问题（任何时候都是单例）
• 什么是“反序列化问题”？ 答：就是，即使你的单例类的构造器是private的，但是到反序列化那一步的时候，依然会通过特殊手段去调用该方法，来实例化一个新的实例。【so，将对象写入磁盘，再读取出来的过程，就会新建对象，而不是用回原来的实例。】

6. 使用容器
   使用容器，同样能实现单例模式。

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