深入学习单例模式

单例保证一个类只有一个实例，并提供一个访问它的全局访问点。
好处是，减少内存开销，，避免频繁创建和销毁实例。
加载，表示启动程序的文件或信息的存入内存

java中类的字节码文件加载进内存，就是内容以io流的形式存入内存。

User user=new User(“男”，26)；
该语句做了几件事：

1. 因为new用到了User.class，所以找到User.class文件并加载到内存中
2. 执行该类的static代码块，如果有的话，给User.class类进行初始化
3. 在堆内存中开辟空间，分配内存地址。
4. 在堆内存中建立对象的特有属性，并进行默认初始化。
5. 对属性进行显式初始化
6. 对对象进行构造代码块初始化
7. 对对象进行对应的构造函数初始化
8. 将内存地址赋给栈内存中的p变量

简化为三步

1. 分配对象内存
2. 调用构造器方法，执行初始化
3. 将对象赋值给变量
   虚拟机实际运行时，以上代码2 3可能发生重排序，但是并不会重排序1这个指令，因为23都需要依托1指令的执行结果。

Java 语言规规定了线程执行程序时需要遵守 intra-thread semantics。 **intra-thread semantics ** 保证重排序不会改变单线程内的程序执行结果。这个重排序在没有改变单线程程序的执行结果的前提下，可以提高程序的执行性能。

虽然重排序并不影响单线程内的执行结果，但是在多线程的环境出现内存可见性问题。

1.饿汉式单例

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

这样的代码缺点是：第一次加载类的时候会连带着创建Singleton实例，这样的结果与我们所期望的不同，因为创建实例的时候可能并不是我们需要这个实例的时候。同时如果这个Singleton实例的创建非常消耗系统资源，而应用始终都没有使用Singleton实例，那么创建Singleton消耗的系统资源就被白白浪费了，类加载时完成初始化，类加载较慢，但获取对象速度快。

为了避免这种情况，我们通常使用惰性加载的机制，也就是在使用的时候才去创建。以上代码的惰性加载代码如下：

2.懒汉式单例

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

线程安全问题

这是如果两个线程A和B同时执行了该方法，然后以如下方式执行：

1. A进入if判断，此时instance为null，因此进入if内
2. B进入if判断，此时A还没有创建instance，因此instance也为null，因此B也进入if内
3. A创建了一个instance并返回
4. B也创建了一个instance并返回

此时问题出现了，我们的单例被创建了两次，而这并不是我们所期望的。

3.懒汉式加锁

以上问题最直观的解决办法就是给getInstance方法加上一个synchronize前缀，这样每次只允许一个现成调用getInstance方法：

public static synchronized Singleton getInstance(){        
    if (instance == null)        
    instance = new Singleton();         
    return instance;         
}  

这种解决办法的确可以防止错误的出现，但是它却很影响性能：每次调用getInstance方法的时候都必须获得Singleton的锁，而实际上，当单例实例被创建以后，其后的请求没有必要再使用互斥机制了，造成不必要的同步开销，不建议使用。

4.double-checked locking 双重检查模式锁（DCL）

public class Singleton {  
      private volatile static Singleton instance;  
      private Singleton (){
      }   
      public static Singleton getInstance() {  
      if (instance== null) {  
          synchronized (Singleton.class) {  
          if (instance== null) {  
              instance= new Singleton();  
          }  
         }  
     }  
     return singleton;  
     }  
 }  

这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字，双重检查模式是正确使用volatile关键字的场景之一。
在这里使用volatile会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。 DCL优点是资源利用率高，第一次执行getInstance时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。DCL虽然在一定程度解决了资源的消耗和多余的同步，线程安全等问题，但是他还是在某些情况会出现失效的问题，也就是DCL失效，在《java并发编程实践》一书建议用静态内部类单例模式来替代DCL。如果不加volatile，就出现了文章开头的内存可见性问题。

• A、B线程同时进入了第一个if判断
• A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();
• JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员，由于JVM内部的优化机制（重排序），注意此时JVM没有开始初始化这个实例，此时intance已经不为null,
• B进来，由于instance此时不是null，因此它return instance。
• B线程打算使用Singleton实例，却发现它没有被初始化，于是空指针异常。

volatile作用

1. 保证可见性，使用volatile定义的变量，将会保证对所有线程可见性
2. 禁止指令重排序优化。
   注意，volatile不能保证原子性
   这里由于禁止对象创建时指令重排序，所以其他线程不会访问到一个未初始化的对象。
   https://www.infoq.cn/article/java-memory-model-1/?utm_source=infoq&utm_medium=related_content_link&utm_campaign=relatedContent_articles_clk

https://blog.youkuaiyun.com/javageektech/article/details/99619318
https://blog.youkuaiyun.com/itachi85/article/details/51480553
https://www.infoq.cn/news/double-checked-locking-with-delay-initialization

5.基于类初始化实现多线程环境中的单例模式

为了实现慢加载，并且不希望每次调用getInstance时都必须互斥执行，最好并且最方便的解决办法如下：

public class Singleton{        
    private Singleton(){        
        …        
    }        
    private static class SingletonContainer{        
        private static Singleton instance = new Singleton();        
    }        
    public static Singleton getInstance(){        
        return SingletonContainer.instance;        
    }        
} 

JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。（JVM在类的初始化阶段（即在Class被加载后，且被线程使用之前），会执行类的初始化。在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。相比其他实现方案（如double-checked locking等），该技术方案的实现代码较为简洁，并且在所有版本的编译器中都是可行的。）这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上述中的问题。此外该方法也只会在第一次调用的时候使用互斥机制，这样就解决了上述中的低效问题。最后instance是在第一次加载SingletonContainer类时被创建的，而SingletonContainer类则在调用getInstance方法的时候才会被加载，因此也实现了惰性加载。
静态内部类是不是完美的呢？也不是，就是传参的问题，由于是静态内部类的形式去创建单例的，故外部无法传递参数进去，这时候用DCL+volatile就好