单例模式保证一个类仅有一个实例，并提供一个全局访问点来访问它，这个类称为单例类。可见，在实现单例模式时，除了保证一个类只能创建一个实例外，还需提供一个全局访问点。

Singleton is a creational design pattern that lets you ensure that a class has only one instance, 
while providing a global access point to this instance.  

为提供一个全局访问点，可以使用全局变量，但全局变量无法禁止用户实例化多个对象。为此，可以让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问实例的方法。
综上，单例模式的要点有三个：一是某个类只能有一个实例；二是这个类必须自行创建这个实例；三是这个类必须自行向整个系统提供这个实例。

结构设计

单例模式只有一个角色：
Singleton，单例类，用来保证实例唯一并提供一个全局访问点。为实现访问点全局唯一，可以定义一个静态字段，同时为了封装对该静态字段的访问，可以定义一个静态方法。为了保证实例唯一，这个类还需要在内部保证实例的唯一。基于以上思考，单例模式的类图表示如下：

伪代码实现

接下来将使用代码介绍下单例模式的实现。单例模式的实现方式有很多种，主要的实现方式有以下五种：饿汉方式、懒汉方式、线程安全实现方式、双重校验方式、惰性加载方式。

(1) 饿汉方式

饿汉方式就是在类加载的时候就创建实例，因为是在类加载的时候创建实例，所以实例必唯一。由于在类加载的时候创建实例，如果实例较复杂，会延长类加载的时间。

// 1. 定义单例类，提供全局唯一访问点，保证实例唯一
public class HungrySingleton {
    // (1) 声明并实例化静态私有成员变量(在类加载的时候创建静态实例)
    private static final HungrySingleton instance = new HungrySingleton();
    // (2) 私有构造方法
    private HungrySingleton() {

    }
    // (3) 定义静态方法，提供全局唯一访问点
    public static HungrySingleton getInstance() {
        return instance;
    }

    public void foo() {
        System.out.println("---------do some thing in a HungrySingleton instance---------");
    }
}
// 2. 客户端调用
public class HungrySingletonClient {
    public void test() {
        // (1) 获取实例
        HungrySingleton singleton = HungrySingleton.getInstance();
        // (2) 调用实例方法
        singleton.foo();
    }
}

(2) 懒汉方式

懒汉方式就是在调用实例获取(如getInstance())接口时，再创建实例，这种方式可避免在加载类的时候就初始化实例。

// 1. 定义单例类，提供全局唯一访问点，保证实例唯一
public class LazySingleton {
    // (1) 声明静态私有成员变量
    private static LazySingleton instance;
    // (2) 私有构造方法
    private LazySingleton() {

    }
    // (3) 定义静态方法，提供全局唯一访问点
    public static LazySingleton getInstance() {
        // 将实例的创建延迟到第一次获取实例
        if(instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }

    public void foo() {
        System.out.println("---------do some thing in a LazySingleton instance---------");
    }
}
// 2. 客户端调用
public class LazySingletonClient {
    public void test() {
        // (1) 获取实例
        LazySingleton instance = LazySingleton.getInstance();
        // (2) 调用实例方法
        instance.foo();
    }
}

需要说明的是，对多线程语言来说(如java语言)，懒汉方式会带来线程不安全问题。如果在实例前执行判空处理时，至少两个线程同时进入这行代码，则会创建多个实例。
所以，对于多线程语言来说，为了保证代码的正确性，还需在实例化的时候，保证线程安全。

(3) 线程安全实现方式

为保证线程安全，可以在实例判空前，进行线程同步处理，如添加互斥锁。

// 1. 定义单例类，提供全局唯一访问点，保证实例唯一
public class ThreadSafeSingleton {
    // (1) 声明静态私有成员变量
    private static ThreadSafeSingleton instance;

    // (2) 私有构造方法
    private ThreadSafeSingleton() {

    }
    // (3) 定义静态方法，提供全局唯一访问点
    public static ThreadSafeSingleton getInstance() {
        // 使用synchronized方法，保证线程安全
        synchronized (ThreadSafeSingleton.class) {
            if (Objects.isNull(instance)) {
                instance = new ThreadSafeSingleton();
            }
            return instance;
        }
    }

    public void foo() {
        System.out.println("---------do some thing in a ThreadSafeSingleton instance---------");
    }
}
// 2. 客户端调用
public class ThreadSafeSingletonClient {
    public void test() {
        // (1) 获取实例
        ThreadSafeSingleton instance = ThreadSafeSingleton.getInstance();
        // (2) 调用实例方法
        instance.foo();
    }
}

但是这种方式，会因线程同步而带来性能问题。因为大多数场景下，是不存在并发访问。

(4) 双重校验方式

为避免每次创建实例时加锁带来的性能问题，引入双重校验方式，即在加锁前额外进行实例判空校验，这样就可保证非并发场景下仅在第一次实例化时，去加锁并创建实例。

// 1. 定义单例类，提供全局唯一访问点，保证实例唯一
public class DoubleCheckSingleton {
    // (1) 声明静态私有成员变量
    private static volatile DoubleCheckSingleton instance;
    // (2) 私有构造方法
    private DoubleCheckSingleton() {

    }
    // (3) 定义静态方法，提供全局唯一访问点
    public static DoubleCheckSingleton getInstance() {
        // 在加锁之前，先执行判空检验，提高性能
        if (Objects.isNull(instance)) {
            // 使用synchronized方法，保证线程安全
            synchronized (DoubleCheckSingleton.class) {
                if (Objects.isNull(instance)) {
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }

    public void foo() {
        System.out.println("---------do some thing in a DoubleCheckSingleton instance---------");
    }
}
// 2. 客户端调用
public class DoubleCheckSingletonClient {
    public void test() {
        // (1) 获取实例
        DoubleCheckSingleton instance = DoubleCheckSingleton.getInstance();
        // (2) 调用实例方法
        instance.foo();
    }
}

注意，使用双重校验方式时，需明确语言是否支持指令重排序。以Java语言为例，实例化一个对象的过程是非原子的。具体来说，可以分为以下三步：(1) 分配对象内存空间;(2)将对象信息写入上述内存空间;(3) 创建对上述内存空间的引用。其中(2)和(3)的顺序不要求固定(无先后顺序)，所以存在实例以分配内存空间但还未初始化的情况。如果此时存在并发线程使用了该未初始化的对象，则会导致代码异常。为避免指令重排序，Java语言中可以使用 volatile 禁用指令重排序。更多细节可以参考java单例模式一文。

(5) 惰性加载方式

由于加锁会带来性能损耗，最好的办法还是期望实现一种无锁的设计，且又能实现延迟加载。对Java语言来说，静态内部类会延迟加载(对C#语言来说，内部类会延迟加载)。可以利用这一特性，实现单例。

// 1. 定义单例类，提供全局唯一访问点，保证实例唯一
public class LazyLoadingSingleton {
    // (2) 私有构造方法
    private LazyLoadingSingleton() {

    }
    // (3) 定义静态方法，提供全局唯一访问点
    public static LazyLoadingSingleton getInstance() {
        // 第一调用静态类成员或方法时，才加载静态内部类，实现了延迟加载
        return Holder.instance;
    }

    public void foo() {
        System.out.println("---------do some thing in a LazyLoadingSingleton instance---------");
    }
    // (1) 声明私有静态内部类，并提供私有成员变量
    private static class Holder {
        private static LazyLoadingSingleton instance = new LazyLoadingSingleton();
    }
}
// 2. 客户端调用
public class LazyLoadingSingletonClient {
    public void test() {
        // (1) 获取实例
        LazyLoadingSingleton instance = LazyLoadingSingleton.getInstance();
        // (2) 调用实例方法
        instance.foo();
    }
}

很多框架代码都会引入静态内部类，实现延迟加载。更多静态内部类的使用细节可以参考笔者之前的文章。

适用场景

在以下情况下可以使用单例模式：
(1) 如果系统只需要一个实例对象，则可以考虑使用单例模式。
如提供一个唯一的序列号生成器，或者需要考虑资源消耗太大而只允许创建一个对象。
(2) 如果需要调用的实例只允许使用一个公共访问点，则可以考虑使用单例模式。
(3) 如果一个系统只需要指定数量的实例对象，则可以考虑扩展单例模式。
可以在单例模式中，通过限制实例数量实现多例模式。

优缺点

单例模式模式有以下优点：
(1) 提供了对唯一实例的受控访问。
因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。
(2) 节约系统资源。由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能。
(3) 允许可变数目的实例。可以基于单例模式进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例。
但是单例模式模式也存在以下缺点：
(1) 违反了单一职责原则。单例类的职责过重，既充当工厂角色，提供了工厂方法，同时又充当产品角色，包含一些业务方法，将产品的创建和产品本身的功能融合到一起，在一定程度上违背了单一职责原则。
(2) 单例类扩展困难。由于单例模式中没有抽象层，且继承困难，所以单例类的扩展有很大的困难。
(3) 滥用单例模式带来一些负面问题，如过多的创建单例，会导致这些单例类一直无法释放且占用内存空间，另外对于一些不频繁使用的但占用内存空间较大的对象，也不宜将其创建为单例。而且现在很多面向对象语言(如Java、C#)都提供了自动垃圾回收的技术。

参考

《设计模式：可复用面向对象软件的基础》 Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides 著 李英军, 马晓星 等译
https://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/singleton.html 单例模式
https://refactoringguru.cn/design-patterns/singleton 单例模式
https://www.runoob.com/design-pattern/singleton-pattern.html 单例模式
https://www.cnblogs.com/adamjwh/p/9033554.html 单例模式
https://blog.csdn.net/czqqqqq/article/details/80451880 单例模式