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

Posted 2021-05-01 发哥讲

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

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

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

• 尽量使用细粒度的锁。

  
  

  
  

发哥讲