研磨设计模式系列--单例模式

2020-05-16

1.什么是单例

     保证一个类只有一个实例，并且提供一个访问该全局访问点。

2.单例应用场景

1、Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？不信你自己试试看哦~

2、windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

3、网站的计数器，一般也是采用单例模式实现，否则难以同步。

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

5、Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。

6、数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。

7、多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。

8、操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。

9、HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例.

3.单例优缺点

优点：

1.在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就防止其它对象对自己的实例化，确保所有的对象都访问一个实例。

2.单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。

3.提供了对唯一实例的受控访问。

4.由于在系统内存中只存在一个对象，因此可以节约系统资源，当需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。

5.允许可变数目的实例。

6.避免对共享资源的多重占用。

缺点：

1.不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。

2.由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。

3.单例类的职责过重，在一定程度上违背了“单一职责原则”。

4.滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

4.单例创建方式

1. 饿汉式: 类初始化时,会立即加载该对象，线程天生安全,调用效率高。

2. 懒汉式: 类初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能。

3.静态内部方式:结合了懒汉式和饿汉式各自的优点，真正需要对象的时候才会加载，加载类是线程安全的。

4.枚举单例: 使用枚举实现单例模式优点:实现简单、调用效率高，枚举本身就是单例，由jvm从根本上提供保障避免通过反射和反序列化的漏洞，缺点没有延迟加载。

5.双重检测锁方式，需要保证线程安全问题

下面来看代码演示

为了方便和直观的展示代码，我都在main方法里进行了简单的测试。

1、饿汉式

来看一下饿汉的创建方式，比较简单。

package com.designpattern.singleton;

/**
 * @description: 饿汉式
 * @author: Codegitz
 * @create: 2020-05-17 09:30
 **/
public class Hungry {

    //直接初始化，static保证全局唯一，final保证不允许被修改
    private static final Hungry HUNGRY = new Hungry();

    //私有构造方法
    private Hungry(){}

    //提供返回实例的方法
    public static Hungry getInstance(){return HUNGRY;}

    public static void main(String[] args) {
        Hungry l1 = HUNGRY.getInstance();
        Hungry l2 = HUNGRY.getInstance();
        //测试两个实例是否一样，预测为true
        System.out.println(l1 == l2);
    }
}

2、懒汉式

懒汉式跟上面的大同小异，只是延迟了对象的加载，需要考虑线程安全问题。

package com.designpattern.singleton;

/**
 * @description: 懒汉式
 * @author: Codegitz
 * @create: 2020-05-17 09:30
 **/
public class Lazy {

    //先定义，但是没有初始化
    private static Lazy lazy;

    //私有化构造方法
    private Lazy(){}

    //获取实例，需要保证线程安全问题
    public synchronized static Lazy getInstance(){
        //判断是否为null，为null则初始化，否则直接返回
        if (lazy == null){
            lazy = new Lazy();
        }
        return lazy;
    }

    public static void main(String[] args) {
        Lazy lazy1 = Lazy.getInstance();
        Lazy lazy2 = Lazy.getInstance();
        //测试两个是否为同一个对象，预测为true
        System.out.println(lazy1 == lazy2);
    }
}

3、静态内部类

package com.designpattern.singleton;

/**
 * @description: 静态内部类方式
 * @author: Codegitz
 * @create: 2020-05-17 09:48
 **/
public class InnerClass {
    //私有化构造方法
    private InnerClass(){
        System.out.println("InnerClass constructor....");
    }

    //通过内部类获取InnerClass对象
    public static class InnerSingletonInstance{
        private static final InnerClass innerClass = new InnerClass();
    }

    //提供返回实例方法，此方法没有sync，想想通过什么保证了唯一？
    public static InnerClass getInstance(){
        System.out.println("get InnerClass Instance......");
        return InnerSingletonInstance.innerClass;
    }

    public static void main(String[] args) {
        InnerClass instance1 = InnerClass.getInstance();
        InnerClass instance2 = InnerClass.getInstance();
        //预测返回为true
        System.out.println(instance1 == instance2);
    }

}

优势：兼顾了懒汉模式的内存优化（使用时才初始化）以及饿汉模式的安全性（不会被反射入侵）。

劣势：需要两个类去做到这一点，虽然不会创建静态内部类的对象，但是其 Class 对象还是会被创建，而且是属于永久代的对象。附上内部类的好处和缺点文章分析。

4、枚举方式

使用枚举实现单例模式。

优点: 实现简单、枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞。

缺点: 没有延迟加载。

package com.designpattern.singleton;

/**
 * @description: 枚举单例模式
 * @author: Codegitz
 * @create: 2020-05-17 10:30
 **/
public class EnumSingleton {
    //私有化构造方法
    private EnumSingleton(){}

    //提供返回实例的方法
    public static EnumSingleton getInstance(){
        return EnumSingletonDemo.INSTANCE.getInstance();
    }
    //通过枚举获取实例
    static enum EnumSingletonDemo{
        INSTANCE;
        private EnumSingleton enumSingleton;
        //利用枚举只初始化一次给对象实例化
        private EnumSingletonDemo(){
            enumSingleton = new EnumSingleton();
        }
        public EnumSingleton getInstance(){
            return this.enumSingleton;
        }
    }
    public static void main(String[] args) {
        EnumSingleton instance1 = EnumSingleton.getInstance();
        EnumSingleton instance2 = EnumSingleton.getInstance();
        //预测为true
        System.out.println(instance1 == instance2);
    }
}

5、双重检测锁

利用锁实现单例。

package com.netty.designpattern.singleton;

/**
 * @description: 双重检测锁单例模式
 * @author: Codegitz
 * @create: 2020-05-17 10:30
 **/
public class DoubleCheckSingleton {
    //需要volatile关键字禁止指令重排序，不然双重检测还是会出现线程安全问题
    public static volatile DoubleCheckSingleton singleton ;

    //私有化构造方法
    private DoubleCheckSingleton(){}

    //获取实例
    public static DoubleCheckSingleton getInstance(){
        //判断是否为空,空则进入实例化流程，否则直接返回
        if (singleton == null){
            synchronized (DoubleCheckSingleton.class){
                //获取锁后再进行判断，配合volatile关键字避免多线程环境下出现线程安全问题
                if (singleton == null){
                    singleton = new DoubleCheckSingleton();
                }
            }
        }
        return singleton;
    }

    public static void main(String[] args) {
        DoubleCheckSingleton doubleCheckSingleton1 = DoubleCheckSingleton.getInstance();
        DoubleCheckSingleton doubleCheckSingleton2 = DoubleCheckSingleton.getInstance();
        //预测为true
        System.out.println(doubleCheckSingleton1 == doubleCheckSingleton2);
    }
}

5.单例防止反射漏洞攻击

在构造函数中，只能允许初始化化一次即可。

package com.designpattern.singleton;

/**
 * @description: 防止反射攻击
 * @author: Codegitz
 * @create: 2020-05-17 10:49
 **/
public class BanReflect {
    public static boolean flag = true;

    private BanReflect(){
        //...只允许创建一次
        if (flag){
            flag = !flag;
        }else {
            throw new RuntimeException("二次创建，违反了单例模式");
        }
    }

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        //先初始化一次
        BanReflect banReflect1 = new BanReflect();
        //再使用反射进行获取一次
        Class<?> aClass = Class.forName("com.imooc.netty.designpattern.singleton.BanReflect");
        //获取实例
        BanReflect banReflect2 = (BanReflect) aClass.newInstance();
        //测试结果,反射获取时就会抛异常，不会到这一步
        System.out.println(banReflect1 == banReflect2);
    }
}

测试运行结果如下：

com.designpattern.singleton.BanReflect
Exception in thread "main" java.lang.RuntimeException: 二次创建，违反了单例模式
    at com.imooc.netty.designpattern.singleton.BanReflect.<init>(BanReflect.java:16)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:408)
    at java.lang.Class.newInstance(Class.java:433)
    at com.imooc.netty.designpattern.singleton.BanReflect.main(BanReflect.java:26)

Process finished with exit code 1

附完整代码，需要自取，顺便点个star。

6.如何选择单例创建方式

1.如果不需要延迟加载单例，可以使用枚举或者饿汉式，相对来说枚举性能好于饿汉式。

2.如果需要延迟加载，可以使用静态内部类或者懒汉式，相对来说静态内部类好于懒汉式。

|阅读量()