关于单例

• 目的: 保证对象的唯一性
• 核心: 构造方法私有（这一点和 Fragment 要求的构造方法需 public 冲突）
• 规范
  1. 单例只能有一个对象
  2. 单例自己在内部创建对象
  3. 单例给其他对象提供这个对象
• 优点
  1. 内存中只有一个实例，减少内存开销, 比如频繁的创建和销毁实例
  2. 避免对资源的多重应用（比如写文件）

懒汉式, 线程不安全

• 缺点: 当多个线程调用，会创建多个实例

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;
  }
}

双重检验锁

• 优点: 锁代码块,先判断, 再开锁,

  • 第一个 if 保证了存在则不创建，提高效率
  • 第二个 if 防止多个线程一起进入，创建多个实例

• 缺点: instance = new Singleton()并非一个原子操作, 能拆成:

  1. 给 instance 分配内存
  2. 调用 Singleton 的构造函数来初始化成员变量
  3. 将 instance 对象指向分配的内存空间

• jvm 的即时编译器存在指令重排序的优化, 执行顺序可能是1-2-3或者1-3-2,

public class Singleton {  
  private static Singleton instance;  
  private Singleton (){}  
  public static Singleton getSingleton() {
    if (instance == null) {                         //Single Checked,提高效率
      synchronized (Singleton.class) {
        if (instance == null) {                 //Double Checked
            instance = new Singleton();
        }
      }
    }
    return instance ;
  }
}

双重检验锁优化

• 使用了 volatile, 原因是其禁止指令重排序优化, 而不是可见性（保证线程在本地不会存 instance 的副本，每次都是去主内存中读取）
• 缺点: java5 之前 JMM (Java内存模型)不完善，无法保证 volatile 的屏蔽重排序

public class Singleton {
    private volatile static Singleton instance; //声明成 volatile
    private Singleton (){}
    public static Singleton getSingleton() {
        if (instance == null) {                     
            synchronized (Singleton.class) {
                if (instance == null) {       
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

饿汉式 static final field

• 缺点:并非懒加载，即加载类一开始就被实例化, 即使客户端没有调用 getInstance() 方法, 如果需要在创建时依赖外部参数，则无法使用

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

静态内部类 static nested class

• SingletonHolder 是私有的，外部无法访问，懒汉式
• 不依赖JDK版本
• 读取实例时不同步，没性能缺陷

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

枚举

public enum EasySingleton{
    INSTANCE;
}

总结

• 单例有5种, 饿汉式, 懒汉式, 双重检验锁, 静态内部类, 枚举
• 通常使用饿汉式; 明确懒加载则静态内部类; 反序列化创建对象则使用枚举

PS

• 堆内存放new创建的数组, 对象
• 栈内存放变量, 数组, 对象的引用(首地址)
• GC回收的是堆内存的数据,栈内存的引用会在程序运行到代码块作用域外时自动释放

参考

• 如何正确地写出单例模式
• 菜鸟教程 | 单例模式
• java中堆内存和栈内存详解