JAVA设计模式-创建型-单例模式-优快云博客

1、单例模式

   知识点：
   1、模式定义：一个类只有一个实例，提供一个全局的访问点
   应用场景：重量级别的对象，不需要多个实例，如线程池，数据库连接池等
   类图分析：实例对象a 和一个getInstance方法

   2、字节码知识，字节码指令重排序
       通过javap -v a.class 查看指令过程

       创建对象(会涉及到指令排序)，会有四个步骤
       1 分配对象的内存空间
       2 初始化对象
   3 设置instance指向刚分配的内存地址
       4 返回

       指令顺序可能会经过JVM和CPU的优化，指令重排（2，3步骤可能会错乱导致会出现多个实例）

       解决指令重排的方法，volatile关键字，会让JVM的顺序按照指定顺序执行

   3、类加载机制
       3.1、加载二进制数据到内存中，生成对应的Class数据结构
       3.2、连接：a 验证（class是否符合jvm规范） b 准备（给类的静态变量赋值） c 解析
       3.3、初始化：给类的静态变量赋初始值

       真正使用类时，才会进行初始化

   4、JVM序列化机制

       静态内部类--需要实现readResolve()方法，才支持反序列化

           实现serializable接口，并生成序列id(不生成的话，就会导致序列化和反序列化的对象不相同)

           //序列化-该对象必须实现serializable
           objectOutPutStream.writeObject(对象实例A)
           //反序列化
           A = objectOutPutStream.readObject();
           默认情况下，序列化和反序列化两个对象是不相同的
               要想一致，对象A必须要新增readResolve()方法（serializable接口中说明），返回单例对象A

       枚举--本身就支持反序列化，不需要添加任何操作


   5、单例模式在spring框架和 JDK源码中的应用



   6、五种实现方式

       1.1、懒汉式，用到才会new对象----延迟加载，不安全（1、方法级别锁，影响性能，2、代码块锁）
           static A a;
           A static getInstance(){ if(A == null) { a = new A();}}

       1.2、饿汉式，先new对象

       1.3、上述都是线程不安全的-----双重检测机制-线程安全-懒加载-不能防止反射
           A static getInstance(){
               if(A == null) {
                   synchronized(A.class){
                       if(A == null) {
                           a = new A();
                       }
                   }
               }
               return a;
           }
           双重检测机制，以上还有一个隐藏漏洞
               通过javap -v a.class 查看指令过程

               创建对象涉及到指令重排
                   instance = new Singleton() 这行代码会被编译器译成如下JVM指令
                   memory = allocate() // 1 分配对象的内存空间
                   ctorInstance(memory) // 2 初始化对象
                   instance = memory // 3 设置instance指向刚分配的内存地址

               指令顺序可能会经过JVM和CPU的优化，指令重排（2，3步骤可能会错乱）
                   memory = allocate() // 1 分配对象的内存空间
                   instance = memory // 3 设置instance指向刚分配的内存地址
                   ctorInstance(memory) // 2 初始化对象

               这样就导致不为null时，对象还没初始化完成，这样会返回一个未初始化完成的对象


           解决方案：需要在instance对象的前面增加一个volatile修饰词
               volatile关键字，会让JVM的顺序按照指定顺序执行

       1.4、静态内部类实现-线程安全-懒加载-不能防止反射
           private static class Holder{
               private static final Singleton INSTANCE = new Singleton()
           }

           private Singleton(){}

           public static Singleton getInstance(){
               return Holder.INSTANCE;
           }

           内部使用classloader来保持线程安全的

           缺陷：可以通过反射，创建对个对象（1、获取构造器 2、设置构造器可用 3、newInstance方法构造对象）

           如何阻止反射：
               1、枚举
               2、在默认构造方法中，再次判断实例是否为空，不为空就自定义异常，防止反射调用

       1.5、枚举-线程安全-不是懒加载-能防止反射------------优先使用
           public class Singleton {
               public enum SingletonEnum{
                   INSTANCE;
                   private Singleton singleton;

                   private SingletonEnum(){
                       System.out.print("初始化单例")
                       singleton = new Singleton();
                   }

                   private Singleton getInstance(){
                       return singleton;
                   }
               }

               private Singleton(){}

               public static Singleton getInstance(){
                   return SingletonEnum.INSTANCE.getInstance();
               }

           }