Java--JUC--单例模式

1. 饿汉式单例模式

   1. package com.model.danli;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/6/10 9:05
       */
      /**
       * 饿汉模式，即 上来就直接会创建一个对象
       *
       * 可能会浪费空间
       * */
      public class EHanDemo {
          
      　　//构造器私有
          private EHanDemo(){}
      
          private static final EHanDemo eHanDemo=new EHanDemo();
      
          public static EHanDemo getEHanDemo(){
              return  eHanDemo;
          }
      }

2. 懒汉式单例模式
   1. 　　

      package com.model.danli;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/6/10 9:17
       */
      
      /**
       * 懒汉式单例： 不是一上来就加载对象，而是等到我们需要的时候在创建
       *
       *
       *
       * */
      
      public class LazyMan {
      
          private LazyMan(){
              System.out.println(Thread.currentThread().getName()+"线程创建ok");
          }
          private static LazyMan lazyMan;
      
      
          //存在的问题：单线程下是有效的，但是当多线程时我们会造成多个对象的创建
          public LazyMan getLazyMan(){
              if (lazyMan==null){
                  lazyMan=new LazyMan();
              }
              return lazyMan;
          }
      
          public static void main(String[] args) {
              LazyMan lazyMan=new LazyMan();
              for (int i = 0; i < 10; i++) {
                  new Thread(() ->{
                     lazyMan.getLazyMan();
                  },String.valueOf(i)).start();
              }
          }
      }

       

3. 双重检测锁模式的 懒汉式单例 DCL 

   1. package com.model.danli;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/6/10 9:17
       */
      
      /**
       * 懒汉式单例： 不是一上来就加载对象，而是等到我们需要的时候在创建
       *
       *
       *
       * */
      
      public class LazyMan_DCL {
      
          private LazyMan_DCL(){
              System.out.println(Thread.currentThread().getName()+"线程创建实例ok");
          }
          private static volatile LazyMan_DCL lazyMan;
      
      
          //双重检测锁模式，懒汉式单例，DCL单例
          public static LazyMan_DCL getLazyMan(){
              if (lazyMan==null){
                  synchronized(LazyMan_DCL.class){
                      if (lazyMan==null){
                          /*
                          * 不是原理性操作
                          * 底层的操作：
                          * 1.分配内存空间
                          * 2.执行构造方法，初始化对象
                          * 3.把这个对象指向这个空间
                          *
                          * 有可能会发生指令的重排--》解决方法 ：使用 volatile修饰变量layMan
                          * */
                          lazyMan=new LazyMan_DCL();
                      }
                  }
              }
              return lazyMan;
          }
      
          public static void main(String[] args) {
              for (int i = 0; i < 10; i++) {
                  new Thread(() ->{
                     LazyMan_DCL.getLazyMan();
                  },String.valueOf(i)).start();
              }
          }
      }

4. 反射机制可以破坏单例模式

   1. package com.model.danli;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/6/10 9:17
       */
      
      import java.lang.reflect.Constructor;
      import java.lang.reflect.InvocationTargetException;
      
      /**
       * 懒汉式单例： 不是一上来就加载对象，而是等到我们需要的时候在创建
       *
       *
       *
       * */
      
      public class LazyMan_DCL_FS {
      
          private LazyMan_DCL_FS(){
              System.out.println(Thread.currentThread().getName()+"线程创建实例ok");
          }
          private static volatile LazyMan_DCL_FS lazyMan;
      
      
          //双重检测锁模式，懒汉式单例，DCL单例
          public static LazyMan_DCL_FS getLazyMan(){
              if (lazyMan==null){
                  synchronized(LazyMan_DCL_FS.class){
                      if (lazyMan==null){
                          /*
                          * 不是原理性操作
                          * 底层的操作：
                          * 1.分配内存空间
                          * 2.执行构造方法，初始化对象
                          * 3.把这个对象指向这个空间
                          *
                          * 有可能会发生指令的重排--》解决方法 ：使用 volatile修饰变量layMan
                          * */
                          lazyMan=new LazyMan_DCL_FS();
                      }
                  }
              }
              return lazyMan;
          }
      
          public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
             /* for (int i = 0; i < 10; i++) {
                  new Thread(() ->{
                     LazyMan_DCL.getLazyMan();
                  },String.valueOf(i)).start();
              }*/
      
              //反射机制,能破坏单例模式：那我们呢如何解决呢？
              Constructor<LazyMan_DCL_FS> dclConstructor= LazyMan_DCL_FS.class.getDeclaredConstructor(null);
              dclConstructor.setAccessible(true);
              LazyMan_DCL_FS instance=dclConstructor.newInstance();
              LazyMan_DCL_FS instance2=dclConstructor.newInstance();
              System.out.println(instance);
              System.out.println(instance2);
          }
      }

5.  

   解决反射机制的对单例模式的破坏：反射不能破坏enum的单例

   1. package com.model.danli;
      
      import java.lang.reflect.Constructor;
      import java.lang.reflect.InvocationTargetException;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/6/10 13:30
       */
      public enum EnumDemo {
          INSTANCE;
          public EnumDemo getInstance(){
              return INSTANCE;
          }
      
      }
      class Test{
          public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
              EnumDemo enumDemo=EnumDemo.INSTANCE;
              Constructor<EnumDemo> demoConstructor=EnumDemo.class.getDeclaredConstructor(String.class,int.class);
              demoConstructor.setAccessible(true);
              EnumDemo enumDemo1=demoConstructor.newInstance();
              System.out.println(enumDemo);
              System.out.println(enumDemo1);
          }
      }

       

   2.