设计模式——单例模式

一、定义

单例模式，也叫单子模式，是一种常用的软件设计模式，属于创建型模式的一种。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。

比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。又比如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

二、特点

单例类只有一个实例对象；
该单例对象必须由单例类自行创建；
单例类对外提供一个访问该单例的全局访问点。

三、优缺点

单例模式的优点：

单例模式可以保证内存里只有一个实例，减少了内存的开销。
可以避免对资源的多重占用。
单例模式设置全局访问点，可以优化和共享资源的访问。

单例模式的缺点：

单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

四、应用场景

单例模式的应用场景主要有以下几个方面：

需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC。
某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。
某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。
某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。
频繁访问数据库或文件的对象。
对于一些控制硬件级别的操作，或者从系统上来讲应当是单一控制逻辑的操作，如果有多个实例，则系统会完全乱套。
当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。

五、实现思路

实现单例模式的思路：

一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法（必须是静态方法，通常使用 getInstance 这个名称）；
当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；
同时我们还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。

UML ：

单例模式的结构图

单例模式在多线程的应用场合下必须小心使用：

如果当唯一实例尚未创建时，有两个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，从而同时各自创建了一个实例，这样就有两个实例被构造出来，从而违反了单例模式中实例唯一的原则。解决这个问题的办法是为指示类是否已经实例化的变量提供一个互斥锁(虽然这样会降低效率)。

六、单例模式的实现

单例模式通常有两种实现形式：懒汉式单例与饿汉式单例。

懒汉式单例

1. 线程不安全的懒汉式

特点：因为没有加锁 synchronized，所以在多线程时不能正常工作。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
package pers.designPattern.singleton;

public class NonThreadSafeLazy {
    /*
    * 线程不安全的懒汉式
    * */
    private static NonThreadSafeLazy instance = null;

    private NonThreadSafeLazy() {
        // 避免在外部实例化
    }

    public static NonThreadSafeLazy getInstance() {
        if (instance == null) {
            instance = new NonThreadSafeLazy();
        }
        return instance;
    }
}

2. 线程安全的懒汉式

特点：这种实现方式第一次调用才初始化实例，避免内存浪费；但是效率很低，因为这种加锁方式会影响效率。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
package pers.designPattern.singleton;

public class ThreadSafeLazy {
    /*
    * 线程安全的懒汉式
    * */
    private static ThreadSafeLazy instance;  // 保证 instance 在所有线程中同步

    private ThreadSafeLazy() {}

    public static synchronized ThreadSafeLazy getInstance() {
        // getInstance 方法前加 synchronized 为了保证线程安全
        if (instance == null) {
            instance = new ThreadSafeLazy();
        }
        return instance;
    }
}

3. 双检锁的懒汉式

特点：采用双检索（DCL，即 double-checked locking）模式，能够保证线程安全且在多线程情况下能保持高性能。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
package pers.designPattern.singleton;

public class DCLLazy {
    /*
    * 采用双检锁（DCL，double-checked locking）实现的懒汉式
    * */
    private static volatile DCLLazy instance;

    private DCLLazy() {}

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

4. 静态内部类的懒汉式（推荐）

加载一个类时，其内部类不会同时被加载。一个类被加载，当且仅当其某个静态成员（静态域、构造器、静态方法等）被调用时发生。由于在调用 StaticSingleton.getInstance() 的时候，才会对单例进行初始化，而且通过反射，是不能从外部类获取内部类的属性的；由于静态内部类的特性，只有在其被第一次引用的时候才会被加载，所以可以保证其线程安全性。

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
package pers.designPattern.singleton;

public class StaticInnerClassLazy {
    /*
    * 采用静态内部类实现的懒汉式
    * */
    private static class StaticInnerClassLazyHolder {
        private static final StaticInnerClassLazy instance = new StaticInnerClassLazy();
    }

    private StaticInnerClassLazy() {}

    public static StaticInnerClassLazy getInstance() {
        return StaticInnerClassLazyHolder.instance;
    }
}

饿汉式单例模式

1. 饿汉式

特点：没有加锁，执行效率会提高；但是类加载时就初始化实例，浪费内存。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
package pers.designPattern.singleton;

public class Hungry {
    /*
    * 饿汉式单例模式
    * */
    private static Hungry instance = new Hungry();

    private Hungry() {}

    public static Hungry getInstance() {
        return instance;
    }
}

2. 枚举实现饿汉式

特点：创建枚举默认就是线程安全的，所以不需要担心double checked locking，而且还能防止反序列化导致重新创建新的对象。保证只有一个实例（即使使用反射机制也无法多次实例化一个枚举量）。

1
2
3
4
5
6
7
8
package pers.designPattern.singleton;

public enum EnumerationHungry {
    /*
    * 采用枚举的方式实现饿汉式单例模式
    * */
    INSTANCE;
}

参考：
菜鸟教程
C语言网
https://refactoringguru.cn/