Java23种设计模式之单例模式的五种实现方式、反射破解单例模式、不能破解枚举单例模式详解

源码链接（Gitee码云）：https://gitee.com/oldou/javadesignpatterns
这里有我整理好的Java23种设计模式的源码以及博客教程，博客教程中介绍了Java23种设计的模式的各种实现方式以及应用场景，非常适用于学习以及提高我们的设计思维，如果对大家有所帮助，请记得star一下给予作者一定的精神支持，你的star是我写出更好的博客的动力，谢谢大家。

设计模式简介

将设计者的思维融入大家的学习和工作中，更高层次的思考！
• 创建型模式：
– 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。

• 结构型模式：
– 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

• 行为型模式：
– 模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

本次文章介绍的是单例模式的五种实现方式。

单例模式的简介

• 核心作用：
保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

• 常见应用场景：
– Windows的Task Manager（任务管理器）就是很典型的单例模式
– windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
– 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。
– 网站的计数器，一般也是采用单例模式实现，否则难以同步。
– 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
– 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
– 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
– Application 也是单例的典型应用（Servlet编程中会涉及到）
– 在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理
– 在servlet编程中，每个Servlet也是单例
– 在spring MVC框架/struts1框架中，控制器对象也是单例

• 单例模式的优点：
– 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，
则可 以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决

– 单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理

• 常见的五种单例模式实现方式：
– 主要：
• 饿汉式（线程安全，调用效率高。 但是，不能延时加载。）
• 懒汉式（线程安全，调用效率不高。 但是，可以延时加载。）

– 其他：
• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
• 静态内部类式(线程安全，调用效率高。 但是，可以延时加载)
• 枚举单例(线程安全，调用效率高，不能延时加载)

单例模式的实现

实现方式一：饿汉式（单例对象立即加载）

• 饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字。
• 问题：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！

需要注意的三点：
第一点：需要将构造器私有，构造器私有之后别人就访问不了了，只有自己可以用；
第二点：提供一个属性，这个属性是static变量，并且是私有的，static变量是类变量，从属于这个类，那么这个类就只有这么一个属性，它就指定了这个对象；
第三点：提供一个开放的方法，别人只能从这里取对象。
以上三点的描述，详细代码见以下的第一个！！

/**
 * 测试饿汉式单例模式
 *  --所谓饿汉式，表示的是很饿，上来就把你吃了，相当于当类加载器加载以下类的时候，
 *    加载的时候就把这个对象New出来，初始以下的静态属性，不管你要不要，上来就给建好。
 *    这个就是立即加载。这个就是不好的地方。
 *
 *  --特点：
 *  1.线程安全：方法前不需要加synchronized,因为我们去创建对象时，在类初始化时立刻加载，
 *             在类加载器加载对象时是一个天然的线程安全模式。
 *             不存在创建对象/初始化属性多线程不安全的问题，所以天然线程安全。
 *
 *  2.显然不加同步标记的话，效率就高。
 */
public class Demo01 {
    //类初始化时，立即加载这个对象(没有延时加载的优势)，加载类时，天然的是线程安全的
    private final static Demo01 INSTANCE = new Demo01();

    //提供私有的构造器,一旦构造器私有，别人就无法去new这个对象了，保证了内存中只有这么一个对象
    private Demo01(){}

    //方法没有同步，调用效率高
    public static Demo01 getInstance(){
        return INSTANCE;
    }
}

实现方式二：懒汉式（单例对象延迟加载）

• 要点：
– lazy load! 延迟加载， 懒加载！ 真正用的时候才加载！

• 问题：
– 资源利用率高了。但是，每次调用getInstance()方法都要同步，并发效率较低。
–调用的效率低。

注意：如果类创建对象时用到的代价很高，那么就使用延时加载，也就是懒汉式；如果类调用效率非常频繁，就用饿汉式。

代码为：

/**
 * 懒汉式单例模式
 */
public class Demo02 {
    //类初始化时，不初始化这个对象(实现了延时加载，真正用到的时候才去创建)
    private static Demo02 INSTANCE;

    //构造器私有，一旦构造器私有，别人就无法去new这个对象了，保证了内存中只有这么一个对象
    private Demo02(){}

    //方法同步，调用效率低
    public static synchronized Demo02 getInstance(){
        if(INSTANCE==null){
            INSTANCE = new Demo02();
        }
        return INSTANCE;
    }

}

实现方式三：双重检测锁实现（不建议使用）

• 这个模式将同步内容下方到if内部，提高了执行的效率不必每次获取对象时都进行同步，
只有第一次才同步创建了以后就没必要了。
• 问题：由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题。不建议使用。
代码如下所示：

/**
 * 双重检测锁模式的懒汉式，DCL懒汉式
 */
public class Demo03 {
    private static volatile Demo03 INSTANCE;
    private Demo03(){}

    public static Demo03 getInstance(){
        //先判断对象是否已经实例化过，没有实例化才能进入加锁代码
        if(INSTANCE==null){
            //对类对象加锁
            synchronized (Demo03.class){
                if(INSTANCE==null){
                    INSTANCE = new Demo03();
                }
            }
        }
        return INSTANCE;
    }
}

/**
 * 为什么要加 volatile关键字修饰 instance
 * 我们创建一个对象一般的步骤就是：
 *  1、分配内存空间
 *  2、执行构造方法，初始化对象
 *  3、把这个对象指向对应的内存空间
 *  一般情况下，我们期望的是执行123这样的顺序，但是真实可能执行132，比如这个时候A线程是这样的方式
 *  先分配内存空间，然后在把这个内存空间占用，再把这个对象放进去，在多线程情况下，如果这个时候来了个线程B
 * 线程B过来以后，由于是先去指向对应的内存空间，它会认为 instance 不等于null，它就会直接return回去，
 * 此时的这个instance还没有完成构造，这个时候空间是一片虚无，就会出问题，因此加一个volatile关键字
 * 可以避免指令重排，保证可见性。
 *
**/

实现方式四：静态内部类实现方式(懒加载方式)

基本思路：首先是静态内部类，在里面定义单例对象，然后也提供一个方法getInstance()，通过调用静态内部的方法进行访问，构造器私有，这种方式不仅线程安全，还是懒加载模式。

当我们第一次去初始化这个类的时候，并不会立即初始化它的静态内部类，当真正要用的时候，才会通过getInstance()这个方法去调用InnerClass.INSTANCE ;从而去加载内部类中的代码，使用时也不存在同步的问题。调用效率也不错，很多开源的都用这个。

• 要点：
– 外部类没有static属性，则不会像饿汉式那样立即加载对象。
– 只有真正调用getInstance(),才会加载静态内部类。加载类时是线程安全的。 INSTANCE 是static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性.
– 兼备了并发高效调用和延迟加载的优势！

优点：
1、线程安全，还是懒加载模式
2、调用效率高
3、实现了延时加载
代码实现：

/**
 * 静态内部类实现单例模式
 *
 * 优点：
 * 1、线程安全，还是懒加载模式
 * 2、调用效率高
 * 3、实现了延时加载
 */
public class Demo04 {
    //在静态内部类中定义单例对象，因为第一次初始化这个类时并不会立即初始化静态内部类
    private static class InnerClass{
        private static final Demo04 INSTANCE = new Demo04();
    }
    //构造器私有
    private Demo04(){}

    //通过静态内部类获取实例
    public static Demo04 getInstance(){
        return InnerClass.INSTANCE; //
    }
}

实现方式五：枚举

• 优点：
– 实现简单
– 枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！

• 缺点：
– 无延迟加载

代码如下：

/**
 * 使用枚举方式实现单例模式
 • 优点：
 – 实现简单
 – 枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！
 */
public enum Demo05 {
    /**
     *  定义一个枚举元素，它就代表了Singleton的一个实例
     */
    INSTANCE;
    public Demo05 getInstance(){
        return INSTANCE;
    }

}

反射破解单例模式

以上五种单例模式的实现方式中，前四种方式都是不太安全的，饿汉、懒汉、双重检查锁、静态内部类这四种方式都可以使用反射进行破解。

下面以破解饿汉式为例：

//测试使用反射破坏单例（懒汉为例）
        public static void main(String[] args) throws Exception{
            Demo01 instance = Demo01.getInstance();
            //获取通过反射私有构造器（这里null表示获取无参）
            Constructor<Demo01> declaredConstructor = Demo01.class.getDeclaredConstructor(null);
            //破坏私有构造器
            declaredConstructor.setAccessible(true);
            //通过反射创建对象
            Demo01 instance2 = declaredConstructor.newInstance();
            //通过输出可以明显的看出创建了两个对象，单例模式被破解了
            System.out.println(instance);
            System.out.println(instance2);
        }

可以发现，已经创建了新的对象，按照单例模式的说法，它们应该是一个对象才对，但是结果证明，通过反射能够破解掉单例模式，通过反射创建了两个不同的对象，其他的你们也可以使用这种方式去测试一下，结果都是一样的。

那么我们要怎么解决反射破解单例模式这样的一个问题呢？首先我们可以去查看反射的源码：

源码中我们可以看见这么一句话，如果你的这个类型是枚举类型，想要通过反射去创建对象时会抛出一个异常（不能通过反射创建枚举对象）;

枚举单例模式的解释

枚举是JDK1.5出来的，自带单例模式。
那么我们来看一下枚举怎么实现单例模式：

/**
 * 枚举实现单例
 */
public enum  EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        EnumSingle instance2 = EnumSingle.INSTANCE;

        System.out.println(instance1);
        System.out.println(instance2);
    }
}

输出：

接下来我们测试一下，反射能不能破坏枚举实现的单例：
这里我用原来的代码的进行测试，就是名字不一样而已，将原来的Demo05改为了EnumeSingle。

首先我们查看一下源码中是有参构造还是无参构造，我们一个一个的侧，找到EnumeSingle的class文件，查看里面是无参构造，然后我们使用反射去将私有的构造器的私有属性破除掉。

我们发现class文件里面确实有私有的无参构造器，下面我们去测试一下看能不能通过构造器破解掉枚举的单例模式：

//测试通过反射是否能够破解枚举方式的单例模式
class Test{
    public static void main(String[] args) throws Exception{
        EnumSingle instance1 = EnumSingle.INSTANCE;
        //使用反射获取无参构造器
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        //将构造器的私有属性破除掉
        declaredConstructor.setAccessible(true);
        //获取对象
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);

    }
}

输出：

然后竟然抛出了没有无参构造这么一个异常，它说我们这个类里面没有一个空参的构造器，前面给图中不就有一个无参构造器吗？这难道不是坑爹吗？而反射的newInstance源码中。正常的报错应该是以下错误（不能使用反射创建枚举对象）：

那就说明IDEA骗了我们，IDEA告诉我们EnumeSingle.class文件中有一个无参构造方法，但是通过Java程序运行我们知道这里面根本没有这玩意儿，接下来我们去分析一下是什么原因。

我们使用反编译工具去编译一下，将EnumeSingle.class文件反编译成java文件。

反编译出来的Java文件，查看其中的代码发现IDEA是个骗子，这里用了有参构造，
这个时候我们就去修改代码继续测试：

/**
 * 枚举实现单例
 */
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;
        //使用反射获取无参构造器
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        //将构造器的私有属性破除掉
        declaredConstructor.setAccessible(true);
        //获取对象
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);

    }
}

这个时候输出：

结果还是证明了反射不能破解枚举实现的单例模式，果然如反射的源码中所述不能破解枚举，枚举还是牛逼啊。

单例模式总结

• 常见的五种单例模式实现方式
– 主要：
• 饿汉式（线程安全，调用效率高。 但是，不能延时加载。）
• 懒汉式（线程安全，调用效率不高。 但是，可以延时加载。）
– 其他：
• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
• 静态内部类式(线程安全，调用效率高。 但是，可以延时加载)
• 枚举式(线程安全，调用效率高，不能延时加载。并且可以天然的防止反射和反序列化漏洞！)

• 如何选用?
– 单例对象 占用 资源 少，不需要 延时加载：
• 枚举式 好于 饿汉式

– 单例对象 占用 资源 大，需要 延时加载：
• 静态内部类式 好于 懒汉式

寄言：
学习设计模式时一定要动手去敲代码，再加以理解，尤其是饿汉式和懒汉式，一定要熟悉到自己能够手写出来，因为面试的时候经常会让你手写出来（亲测）。

源码链接（Gitee码云）：https://gitee.com/oldou/javadesignpatterns
这里有我整理好的Java23种设计模式的源码以及博客教程，博客教程中介绍了Java23种设计的模式的各种实现方式以及应用场景，非常适用于学习以及提高我们的设计思维，如果对大家有所帮助，请记得star一下给予作者一定的精神支持，你的star是我写出更好的博客的动力，谢谢大家。