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

Posted 发哥讲

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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 效果时,可以考虑静态内部类的实现方式;若涉及到反序列化创建对象时,大家也可以尝试使用枚举方式。

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

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

  • 尽量使用细粒度的锁。




发哥讲


                





以上是关于6单例模式 Singleton模式 只有一个实例 创建型模式的主要内容,如果未能解决你的问题,请参考以下文章

设计模式之五:单例模式(Singleton Pattern)

Singleton模式(单例模式)

单例模式(Singleton)

单列模式_Singleton:懒汉和恶汉两种模式

SwiftObjective-C 单例模式 (Singleton)

单例模式(Singleton)的6种实现