设计模式之单例模式！

2020-09-01 阅读量

设计者的思维融入到学习工作汇总，更高层次的思考！

创建型模式:

单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式

结构型模式

适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式

行为型模式

模板方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，解释器模式，状态模式，策略模式，职责链模式，访问者模式

单例模式

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

1.Window的Task Manager(任务管理器)就是很典型的单例模式

2.Window的Recycle Bin(回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护者仅有的一个实例

3.项目中，读取配置的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取

4.网站的计数器，一般也是采用单例模式，否则难以同步

5.应用程序的日志应用，一般都采用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加

6.数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源

7.Application也是单例的典型应用（Servlet编程中会涉及到）

8.在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理

9.在servlet编程中，每个Servlet也就是单例

10.在spring MVC/Struts1框架中，控制器对象也是单例

单例模式的优点

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置，产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决
单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理

常见的五种单例模式实现方式：

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

饿汉式实现

package com.yishan.singleton;

/**
* 测试饿汉式单例模式
* @author yishan
*/
public class SingletonDemo1 {
    //  类初始化的时候，立即加载该对象（没有延时加载的优势），无论下面是否使用
    //由于加载类时，天然是线程安全的
    private static SingletonDemo1 instance = new SingletonDemo1();

    private SingletonDemo1(){

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

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

懒汉式实现（单例对象延时加载）

package com.yishan.singleton;

/**
* 测试懒汉式单例模式
* @author yishan
*/
public class SingletonDemo2 {
    //  类初始化的时候，不加载该对象（延时加载）
    private static SingletonDemo2 instance;

    private SingletonDemo2(){

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

要点：lazy load! 延时加载，懒加载！真正用的时候才加载！
问题：资源利用率高了。但是，每次调用getInstance（）方法都要同步，并发效率较低。

双重检测锁实现

package com.yishan.singleton;

/**
* 双重检测锁实现单例模式
* @author yishan
*/
public class SingletonDemo3 {
    public static SingletonDemo3 instance = null;

    public static SingletonDemo3 getInstance(){
        if (instance == null){
            SingletonDemo3 sc;
            synchronized (SingletonDemo3.class){
                sc = instance;
                if (sc == null){
                    synchronized (SingletonDemo3.class){
                        if (sc == null){
                            sc = new SingletonDemo3();
                        }
                    }
                    instance = sc;
                }
            }
        }
        return instance;
    }
    private SingletonDemo3(){

    }
}

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

静态内部类实现方式（也是一种懒加载方式）

package com.yishan.singleton;

/**
* 测试静态内部类实现单例模式
* 这种当时：线程安全，调用效率高，并且实现了延时加载
* @author yishan
*/
public class SingletonDemo4 {

    private static class SingletonClassInstance{
        private static final SingletonDemo4 instance = new SingletonDemo4();

    }

    private SingletonDemo4(){
    }

    //方法没有同步，调用效率高！
    public static SingletonDemo4 getInstance(){
        return SingletonClassInstance.instance;
    }
}

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

使用枚举方式实现单例模式

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

总结

常见的五种单例模式实现方式

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

如何选用？

- 单例对象 占用资源少，不需要延时加载：

    枚举式  好于   饿汉式

- 单例对象 占用资源少，需要延时加载：

    静态内部类式   好于   懒汉式