设计模式-创建型-单例模式

简介
单例的核心就在于单实例，即整个环境中该类有且只能有一个对象。而java创建实例的方式已知的有四种，分别是通过new、clone、反射或者序列化这四种方式去创建实例
特点
1、单例只能有一个实例。
2、单例必须自己创建自己的唯一实例。
3、单例必须给所有其他对象提供这一实例。
优点VS缺点
优点

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理缓存）。
2、避免对资源的多重占用（比如写文件操作）

缺点

单例类的职责过重，里面的代码可能会过于复杂，在一定程度上违背了“单一职责原则”。
如果实例化的对象长时间不被利用，会被系统认为是垃圾而被回收，这将导致对象状态的丢失。

单例模式实现方式思维导图（2大类、6种实现方式）

a.初始化单例时就创建
1.饿汉式
这是最简单的单例
原理
依赖 JVM类加载机制，保证单例只会被创建1次，线程安全

1.JVM在类的初始化阶段(即 在Class被加载后、被线程使用前)，会执行类的初始化
2.在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化

实现

class Singleton {

    // 1. 加载该类时，单例就会自动被创建
    private static  Singleton ourInstance  = new  Singleton();
    
    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例 
    private Singleton() {
    }
    
    // 3. 通过调用静态方法获得创建的单例
    public static  Singleton newInstance() {
        return ourInstance;
    }
}

缺点
2.枚举类型
根据枚举类型的下述特点，满足单例模式所需的 创建单例、线程安全、实现简洁的需求

实现方式
public enum Singleton{

    //定义1个枚举的元素，即为单例类的1个实例
    INSTANCE;
}

// 单例的使用方式：
Singleton singleton = Singleton.INSTANCE;

值得注意的是枚举的方式隐藏了1个空的、私有的 构造方法

private Singleton () {}

b. 按需、延迟创建单例

1. 懒汉式（基础实现）
   懒汉与饿汉区别

饿汉式：单例**创建时机不可控**（缺点），即类加载时 自动创建 单例（优点）
懒汉式：单例创建时机可控，即有需要时，才 手动创建 单例

具体实现

class Singleton {
    // 1. 类加载时，先不自动创建单例
   //  即，将单例的引用先赋值为 Null
    private static  Singleton ourInstance  = null；

    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例 
    private Singleton() {
    }
    
    // 3. 需要时才手动调用 newInstance（） 创建 单例   
    public static  Singleton newInstance() {
    // 先判断单例是否为空，以避免重复创建
    if( ourInstance == null){
        ourInstance = new Singleton();
        }
        return ourInstance;
    }
}

此种基础实现方式存在线程安全的问题
多线程情况下
饿汉式
线程安全，多线程模式下适用，因为JVM只加载一次实例
懒汉式
线程不安全，多线程下不适用
可能存在多个线程调用newInstance（） ，创建出多个实例，导致单例失效。

懒汉式改进
对懒汉式 进行优化，使得适合在多线程环境下运行
同步锁（懒汉式的改进）
原理

• 使用同步锁 synchronized锁住 创建单例的方法 ，防止多个线程同时调用，从而避免造成单例被多次创建
  即，getInstance（）方法块只能运行在1个线程中 若该段代码已在1个线程中运行，另外1个线程试图运行该块代码，则
  会被阻塞而一直等待 而在这个线程安全的方法里我们实现了单例的创建，保证了多线程模式下 单例对象的唯一性

class Singleton {
    // 1. 类加载时，先不自动创建单例
    //  即，将单例的引用先赋值为 Null
    private static  Singleton ourInstance  = null；
    
    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例 
    private Singleton() {
    }
    
// 3. 加入同步锁
public static synchronized Singleton getInstance(){
        // 先判断单例是否为空，以避免重复创建
        if ( ourInstance == null )
            ourInstance = new Singleton();
        return ourInstance;
    }
  // 或者
  public static Singleton getInstance(){
        // 加入同步锁
        synchronized(Singleton.class) {
            if (instance == null)
                instance = new Singleton();
        }
        return instance;
    }
}

缺点
每次访问都要进行线程同步（即 调用synchronized锁)，造成过多的同步开销（加锁 = 耗时、耗能）
实际上只需在第1次调用该方法时才需要同步，一旦单例创建成功后，就没必要进行同步

双重校验锁（懒汉式的改进）
原理
在同步锁的基础上，添加1层 if判断：若单例已创建，则不需再执行加锁操作就可获取实例，从而提高性能
实现

class Singleton {
    private static  Singleton ourInstance  = null；

    private Singleton() {
    }
    
    public static  Singleton newInstance() {
     // 加入双重校验锁
    // 校验锁1：第1个if
    if( ourInstance == null){  // ①
     synchronized (Singleton.class){ // ②
      // 校验锁2：第2个 if
      if( ourInstance == null){
          ourInstance = new Singleton();
          }
      }
  }
        return ourInstance;
   }
}
// 说明
// 校验锁1：第1个if
// 作用：若单例已创建，则直接返回已创建的单例，无需再执行加锁操作
// 即直接跳到执行 return ourInstance

// 校验锁2：第2个 if 
// 作用：防止多次创建单例问题
// 原理
  // 1. 线程A调用newInstance()，当运行到②位置时，此时线程B也调用了newInstance()
  // 2. 因线程A并没有执行instance = new Singleton();，此时instance仍为空，因此线程B能突破第1层 if 判断，运行到①位置等待synchronized中的A线程执行完毕
  // 3. 当线程A释放同步锁时，单例已创建，即instance已非空
  // 4. 此时线程B 从①开始执行到位置②。此时第2层 if 判断 = 为空（单例已创建），因此也不会创建多余的实例

缺点
实现复杂 = 多种判断，易出错
静态内部类
原理
根据 静态内部类 的特性，同时解决了按需加载、线程安全的问题，同时实现简洁。
实现方式

class Singleton {
    
    // 1. 创建静态内部类
    private static class Singleton2 {
       // 在静态内部类里创建单例
      private static  Singleton ourInstance  = new Singleton()；
    }

    // 私有构造函数
    private Singleton() {
    }
    
    // 延迟加载、按需创建
    public static  Singleton newInstance() {
        return Singleton2.ourInstance;
    }

}

// 调用过程说明：
      // 1. 外部调用类的newInstance() 
      // 2. 自动调用Singleton2.ourInstance
       // 2.1 此时单例类Singleton2得到初始化
       // 2.2 而该类在装载 & 被初始化时，会初始化它的静态域，从而创建单例；
       // 2.3 由于是静态域，因此只会JVM只会加载1遍，Java虚拟机保证了线程安全性
      // 3. 最终只创建1个单例