spring 创建一个唯一实例_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 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 效果时，可以考虑静态内部类的实现方式；若涉及到反序列化创建对象时，大家也可以尝试使用枚举方式。

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

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

• 尽量使用细粒度的锁。

发哥讲

                

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

● 扫码关注我们