设计模式-单例

单例模式

饿汉模式
不足：由于static在类加载时就会开始创建，无法对实例做延时加载。

public class HuangurySingleton {
  private static final  HuangurySingleton HUANGURY_SINGLETON= new HuangurySingleton();

  private HuangurySingleton(){}

  public static HuangurySingleton getHuangurySingleton(){
      return HUANGURY_SINGLETON;
  }
}

优化：懒汉
懒汉模式

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

缺点：在多线程并发下实例并不是唯一
优化：懒汉线程安全
懒汉线程安全

public class LazySafeSingleton {

  private static LazySafeSingleton instance;

  private LazySafeSingleton(){}

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

  public static synchronized LazySafeSingleton getInstance1(){
      if(instance == null){
          instance = new LazySafeSingleton();
      }
      return instance;
  }
}

缺点：性能效率
优化：DCL
DCL模式

public class DclSingleton {
  private static volatile DclSingleton instance;

  private DclSingleton(){}

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

缺点：如果没有加volatile,其他子线程可能出现数据不同步问题。
优化：静态内部类/枚举
静态内部类

public class StaticInnerSingleton {
  private StaticInnerSingleton(){}

  public static StaticInnerSingleton getInstance(){
      return SingletonHolder.STATIC_INNER_SINGLETON;
  }

  private static class SingletonHolder{
      private static final StaticInnerSingleton STATIC_INNER_SINGLETON= new StaticInnerSingleton();
  }
}

优点：JVM本身保证了线程安全/没有性能消耗
原因：static,final

总结：

• 饿汉：无法满足延迟加载
• 懒汉：无法保证线程安全
• 懒汉线程安全：无法保证性能
• DCL: 数据的同步
• 静态内部类/枚举：延迟加载/线程安全/性能优势

android中单例模式：

单例模式的造成的内存泄漏
如果有Context的构造参数传入，由于单例的static的生命的周期是整个应用的，如果activity的context传进来，就会造成actviity无法被回收。