6、单例模式 Singleton模式 只有一个实例 创建型模式

1、了解Singleton模式

程序在运行时，通常都会生成很多实例。例如，表示字符串的java . lang . string类的实例与字符串是- -对- -的关系，所以当有1000个字符串的时候，会生成1000个实例。但是，当我们想在程序中表示某个东西只会存在-一个时，就会有“只能创建-一个实例” 的需求。典型的例子有表示程序所运行于的那台计算机的类、表示软件系统相关设置的类等。Singleton 是指只含有一-个元素的集合。因为本模式只能生成-一个实例，因此以Singleton命名。

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

单例模式在Java中的实现方式：

懒汉式，饿汉式，静态内部类，枚举等

2、懒汉式以及双检锁

getInstance（）为简单的懒汉式方式，在多线程是不安全的。

getInstance2（）为双检锁，又叫双重校验锁。既保证了线程安全，又比直接上锁提高了执行效率，还节省了内存空间。推荐使用

package cn.design.single;


import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/**
* @author by lin
* @Classname LazyMan
* @Description 懒汉式
* @Date 2020/4/12 16:36
* @Created in 2020/4/12 16:36 by lin
*/
public class LazyMan {
   //增加标志位 , 防止反射 破坏
   private static boolean flag = false;

   // 保证私有,只有一个
   private LazyMan() {
       synchronized (LazyMan.class) {
           if (!flag) {
               flag = true;
          } else {
               throw new RuntimeException("不要试图使用反射破坏 异常");
          }
      }
  }

   // 避免指令重排
   private volatile static LazyMan lazyMan = null;

   //多线程下 是不安全的
   public static LazyMan getInstance() {
       if (lazyMan == null) {
           lazyMan = new LazyMan();
      }
       return lazyMan;
  }

   // 解决 双检锁
   public static LazyMan getInstance2() {
       if (lazyMan == null) {
           synchronized (LazyMan.class) {
               if (lazyMan == null) {
                   // 并不是一个原子操作
                   lazyMan = new LazyMan();
                   // 可能会出现指令重排
                   /*
                    * 执行流程
                    * 1、分配内存空间
                    * 2、执行构造方法，初始化对象
                    * 3、把这个对象执行这个空间
                    *
                    * 123 正常执行
                    * 132 指令重排
                    *     A 线程 执行到了3
                    *     B 线程进来，此时 lazyMan 未执行 new 初始化操作2， 发生了指令重排， 此地址空间下的对象为空 ， 不安全
                    *     添加 volatile ，避免 指令重排
                    */
              }
          }
      }
       return lazyMan;
  }

   // 反射 对象被破坏 破坏单例
   public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
       Field flag = LazyMan.class.getDeclaredField("flag");
       flag.setAccessible(true);
       Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor();
       declaredConstructor.setAccessible(true);
       LazyMan instance1 = declaredConstructor.newInstance();
       System.out.println(instance1);
       // 道高一尺魔高一丈 修改 flag的值
       flag.set(instance1, false);
//       LazyMan instance = LazyMan.getInstance2();
//       System.out.println(instance);
       Constructor<LazyMan> declaredConstructor2 = LazyMan.class.getDeclaredConstructor();
       declaredConstructor2.setAccessible(true);
       LazyMan instance3 = declaredConstructor2.newInstance();
       System.out.println(instance3);
  }

}

2、饿汉式

package cn.design.single;

/**
* @author by lin
* @Classname HungryMan
* @Description 饿汉式
* @Date 2020/4/12 16:48
* @Created in 2020/4/12 16:48 by lin
*/
public class HungryMan {

   private HungryMan() {
  }

//   private byte[] byte=new byte[1024];

   private static final HungryMan hungryMan = new HungryMan();

   public static HungryMan getInstance() {
       return hungryMan;
  }
   // 问题: 如果此类内部 有很多的变量 会造成性能问题
   // byte 很多的 变量

}

3、静态内部类

package cn.design.single;

/**
* @author by lin
* @Classname Holder
* @Description 静态内部类
* @Date 2020/4/12 16:50
* @Created in 2020/4/12 16:50 by lin
*/
public class Holder {
   private Holder(){}

   public static Holder getInstance(){
       return InnerClass.HOLDER;
  }

   public static class InnerClass{
       private static final Holder HOLDER = new Holder();

  }

}

4、最完美的方式 枚举类

package cn.design.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
* @author by lin
* @Classname EnumSingle
* @Description TODO
* @Date 2020/4/12 18:12
* @Created in 2020/4/12 18:12 by lin
*/

// 1.5 以后出来的
// enum 本身也是一个 class 类

public enum EnumSingle {
  INSTANCE;

  public EnumSingle getInstance() {
      return INSTANCE;
  }
}
class test{
  public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
      EnumSingle instance1 = EnumSingle.INSTANCE;
      EnumSingle instance2 = EnumSingle.INSTANCE;
      System.out.println("instance1 = " + instance1);
      System.out.println("instance2 = " + instance2);
      // 使用反射 破坏尝试
      Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
      declaredConstructor.setAccessible(true);
      EnumSingle newInstance = declaredConstructor.newInstance();
      System.out.println(newInstance);

      /* 问题分析
        * 枚举类底层其实也是class, 集成了 Enum
        * idea 编译结果 和 javap -p xxx.class 反编译,也是 无惨的私有构造, 欺骗了我们
        * 使用jad 工具, 底层其实是 有参的 私有构造 参数为 String , int 俩个
        * 结果得到了 我们的 异常 Cannot reflectively create enum objects
        * declaredConstructor.newInstance(); 源码分析 为 : 为枚举类的时候, 不能create enum objects
        */
  }
}

5、小结

上面就是单例模式的五种主要写法。我们来总结下，一般情况下，懒汉式（包含线程安全和线程不安全方式）都比较少用；饿汉式和双检锁都可以使用，可根据具体情况自主选择；在要明确实现 lazy loading 效果时，可以考虑静态内部类的实现方式；若涉及到反序列化创建对象时，大家也可以尝试使用枚举方式。

要想实现效率高的线程安全的单例，我们必须注意以下两点：

• 尽量减少同步块的作用域；

• 尽量使用细粒度的锁。

发哥讲

                

如果你觉得文章还不错，就请点击右上角选择发送给朋友或者转发到朋友圈~

● 扫码关注公众号,  转载请备注来源,和链接