单例模式

单例模式是简单的设计模式之一，属于创建型模式，它提供了一种创建对象的方式，确保只有单个对象被创建。这个设计模式主要目的是想在整个系统中只能出现类的实例，即一个类只有一个对象。单列模式的解决的痛点就是节约资源，节省时间从两个方面看：

1. 由于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级的对象而言，是很重要的。

2. 因为不需要频创建对象，我们的GC压力也减轻了，而在GC中会有STW(stop the world), 从这一方面也节约了GC的时间，单例模式的缺点：简单的单例模式设计开发都比较简单，但是复杂的单例模式需要考虑线程安全等并发问题。

单例类什么时候被初始化呢？ 类加载的时候就会被初始化，java虚拟机规范严格规定了有且只有四种情况必须立即对类进行初始化，遇到new、getStatic、putStatic、invokeStatic这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这四条指令最常见的java代码场景：

1> 使用new关键字实例化对象

2> 读取一个类的静态字段(被final修饰、已在编译期把结果放在常量池的静态字段除外)

3> 设置一个类的静态字段(被final修饰、已在编译期把结果放在常量池的静态字段除外)

4> 调用一个类的静态方法

现在我们已知道类初始化的四种情况了。

那么我们来列举：八种单例实现方式，再分析其特点。

1. 饿汉式静态块单例：

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

2. 懒汉式双重检查单例：

public class LazyDoubleCheckSingleton{
    private static volatile static LazyDoubleCheckSingleton lazy = null;
    private LazyDoubleCheckSingleton(){}
    public static LazyDoubleCheckSingleton getInstance() {
         if (null == lazy) {
             synchronized(LazyDoubleCheckSingleton.class) {
                  if (null ==  lazy) {
                      lazy = new LazyDoubleCheckSingleton();
                  }
                }
            }
         return lazy;
      }
/**
加synchronized不必多说了，保证线程同步，原子性。
那为什么在静态常量中加volatile呢？
1. volatile 是在内存中可见性的。
2. 防止指令重排序：也就是说在new LazyDoubleCheckSingleton时指令重排序导致其他线程获取到未初始化完的对象。
    instance = new LazyDoubleCheckSingleton()这句，这并非是一个原子操作。事实上在JVM中这句话大概做了下面三件     事。
         1> lazy分配内存，
         2> 调用LazyDoubleCheckSingleton构造函数来初始化成员变量
         3>  将lazy对象指向分配的内存空间(执行完之后就不再为null了)，但是在JVM的即时编译期中存在指令排序的优化。
              也就是说2> 和3> 的顺序是不能保证的，最终的执行顺序可能是1>2>3也有可能是1>3>2，如果是1>3>2的话，                  则在3> 执行完毕、2> 未执行之前，被线程二抢占了，这时lazy已经是非null了(但却没有初始化)，所以线程二会                直接返回lazy,但是无法使用。
  3. 内存屏障参考： https://zhuanlan.zhihu.com/p/43526907
*/

3. 懒汉式静态内部类方式实现单列

// 性能优于双重检查的懒汉模式
// 使用内部类可以避免多线程环境下不安全的问题，
// JVM对一个类的初始化会做限制，
// 同一个时间只会允许一个线程去初始化一个类，
// 这样从JVM层面避免了大部分单例实现的问题
public class LazyInnerClassSingleton{
   // 默认使用LazyInnerClassSingleton，先初始化内部类
   // 如果没使用的话，内部类是不加载的
   // 为什么在私有的构造函数中加判空判断呢，是为了防止通过反射方式来创建实例
   // 强制用指定的静态方法来实例化实例
   private LazyInnerClassSingleton(){
      if (LazyHolder.LAZY != null) {
         throw new RuntimeException("不允许创建多个实例！")
      }
   }
  
  // 每一个关键字都不是多余的
  // static是为了使单例的空间共享
  // 保证这个方法不会被重写，重载
  public static LazyInnerClassSingleton getInstance() {
    // 在返回结果之前，一定会先加载内部类。
     return LazyHolder.LAZY;
  }

  // 默认不加载  
  private static class LazyHolder{
     private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
  }
}
/**
静态内部类实现单例，静态内部类不被调用时，默认是不会加载的。LazyInnerClassSingleton加载时，并不需要立即加载LazyHolder，内部类不被加载则不会去初始化，故不占用内存。只有当LazyInnerClassSingleton第一次被加载时， 且调用getInstance()方法时，调用了内部类，此时内部类去加载，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。无论多少个线程去创建，都只会返回一个实例，返回的地址都是同一个。
*/

4. 枚举单例  

   public enum EnumSingleton{
      INSTANCE;
      private Object data;
      public Object getData() {return data;}
      public static EnumSingleton getInstance(){return INSTANCE;}
   }
《Effective Java》Josh Bloch推荐使用此方法实例单例，线程安全，并发好，抵御反射攻击，序列化和反序列化安全。

5. 容器式单例

// Spring中bean的获取也是通过这种方式
public class ContainerSingleton{
     private ContainerSingleton(){}
     private static Map ioc = new ConcurrentHashMap<>();
     public static Object getInstance(String className){
          synchronized(ioc) {
             if (!ioc.containsKey(className)) {
                Object obj = null;                  
                try{
                   obj = Class.forName(className).newInstance();
                   ioc.put(className, obj);
                 }catch(Exception e) {
                     e.printStackTrance();
                 }         
            } 
           return ioc.get(className);    
        }
     }

6. 序列化单例

    public class SeriableSingleton implements Seria{
         private static final SeriableSingleton INATANCE = new SeriableSingleton();
         private SeriableSingleton(){}
         public static SeriableSingleton getInstance(){
             return INATANCE;
         }
         private Object readResolve(){return INATANCE;}
    }
/**
序列化就是把内存中的状态通过转成字节码的形式，从而转换一个IO流，写入到其他地方(可以是磁盘、网络IO)
内存中状态给永久保存下来了。
反序列化就是将已经持久化的字节码内容、转换为IO流，通过IO流的读取，进而将读取的内容转换为Java对象
在转换过程中会重新创建对象new。
为什么要加readResolve()这个方法呢？ 参考：https://blog.csdn.net/u014653197/article/details/78114041
*/

7. ThreadLocalSingleton单例

public class ThreadLocalSingleton{
     private static final ThradLocal threadLocalInstance = new ThreadLocal(){
         @Override
         protected ThreadLocalSingleton initialValue() {
             return new ThreadLocalSingleton();
         }
     }
    public static ThreadLocalSingleton getInstance() {return threadLocalInstance.get()}
}
// 此种单例常用于数据库连接池中，线程之间是隔离。

总结：单例模式的特点：

            1. 私有化构造器
               为什么要私有化呢，如果构造器是public修饰，那完全可以通过new来实例化该类的对象。这样其他处的代码就无法通                  过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。

           2. 保证线程安全
                在多线程情况下，保证原子性。像饿汉式，枚举单例，双重检查，内部类式单例等都是线程安全的。

            3. 延迟加载
               保证没有被使用之前是不会加载内存中的，

            4. 防止序列化和反序列化破坏单列

            5. 防御反射攻击单列

那么class的生命周期一般来说会经历加载、连接、初始化、使用、和卸载五个阶段：参考： https://www.jianshu.com/p/9f369a17d1fb

单例设计模式是23种设计模式常见的模式，也是我们熟知的模式。

此文章也参考了： 
                         https://juejin.im/post/5b50b0dd6fb9a04f932ff53f
                         https://cloud.tencent.com/developer/article/1177048
                         https://www.jianshu.com/p/9f369a17d1fb
文章中还有几处知识点还没有具体整理出来。