首页 > 其他分享> > 02.创建型：单例设计模式2

02.创建型：单例设计模式2

2022-09-08 19:30:23 作者：互联网

创建型：单例设计模式2

目录介绍

01.如何实现一个单例
02.饿汉式实现方式
03.懒汉式实现方式
04.双重DCL校验模式
05.静态内部类方式
06.枚举方式单例
07.容器实现单例模式

01.如何实现一个单例

介绍如何实现一个单例模式的文章已经有很多了，但为了保证内容的完整性，这里还是简单介绍一下几种经典实现方式。概括起来，要实现一个单例，我们需要关注的点无外乎下面几个：
- 构造函数需要是 private 访问权限的，这样才能避免外部通过 new 创建实例；
- 考虑对象创建时的线程安全问题；
- 考虑是否支持延迟加载；
- 考虑 getInstance() 性能是否高（是否加锁）。

02.饿汉式实现方式

饿汉式的实现方式比较简单。在类加载的时候，instance 静态实例就已经创建并初始化好了，所以，instance 实例的创建过程是线程安全的。不过，这样的实现方式不支持延迟加载，从名字中我们也可以看出这一点。具体的代码实现如下所示：

//饿汉式单例类.在类初始化时，已经自行实例化   
public class Singleton { 
    //static修饰的静态变量在内存中一旦创建，便永久存在
    private static Singleton instance = new Singleton(); 
    private Singleton (){} 
    public static Singleton getInstance() { 
        return instance; 
    } 
}

代码分析
- 饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。其中 instance = new Singleton()可以写成：
```
static { 
    instance = new Singleton(); 
}
```
有人觉得这种实现方式不好
- 因为不支持延迟加载，如果实例占用资源多（比如占用内存多）或初始化耗时长（比如需要加载各种配置文件），提前初始化实例是一种浪费资源的行为。最好的方法应该在用到的时候再去初始化。
- 不过，我个人并不认同这样的观点。如果初始化耗时长，那我们最好不要等到真正要用它的时候，才去执行这个耗时长的初始化过程，这会影响到系统的性能（比如，在响应客户端接口请求的时候，做这个初始化操作，会导致此请求的响应时间变长，甚至超时）。采用饿汉式实现方式，将耗时的初始化操作，提前到程序启动的时候完成，这样就能避免在程序运行的时候，再去初始化导致的性能问题。
- 如果实例占用资源多，按照 fail-fast 的设计原则（有问题及早暴露），那我们也希望在程序启动时就将这个实例初始化好。如果资源不够，就会在程序启动的时候触发报错（比如 Java 中的 PermGen Space OOM），我们可以立即去修复。这样也能避免在程序运行一段时间后，突然因为初始化这个实例占用资源过多，导致系统崩溃，影响系统的可用性。

03.懒汉式实现方式

有饿汉式，对应地，就有懒汉式。懒汉式相对于饿汉式的优势是支持延迟加载。具体的代码实现如下所示：
```
//懒汉式单例类.在第一次调用的时候实例化自己  
public class Singleton { 
    //私有的构造函数
    private Singleton() {}
    //私有的静态变量
    private static Singleton single=null; 
    //暴露的公有静态方法 
    public static Singleton getInstance() { 
        if (single == null) {   
            single = new Singleton(); 
        }   
        return single; 
    } 
}
```
- 代码分析
  - 懒汉式（线程不安全）的单例模式分为三个部分：私有的构造方法，私有的全局静态变量，公有的静态方法。
  - 起到重要作用的是静态修饰符static关键字，我们知道在程序中，任何变量或者代码都是在编译时由系统自动分配内存来存储的，而所谓静态就是指在编译后所分配的内存会一直存在，直到程序退出内存才会释放这个空间，因此也就保证了单例类的实例一旦创建，便不会被系统回收，除非手动设置为null。
- 优缺点
  - 优点：延迟加载（需要的时候才去加载）
  - 缺点：线程不安全，在多线程中很容易出现不同步的情况，如在数据库对象进行的频繁读写操作时。
上面这个可以看到是线程不安全的，其实还可以演变一下：
```
public class Singleton { 
    //私有的静态变量
    private static Singleton instance; 
    //私有的构造方法
    private Singleton (){}；
    //公有的同步静态方法
    public static synchronized Singleton getInstance() { 
        if (instance == null) { 
            instance = new Singleton(); 
        } 
        return instance; 
    } 
} 
```
- 代码分析
  - 这种单例实现方式的getInstance（）方法中添加了synchronized 关键字，也就是告诉Java（JVM）getInstance是一个同步方法。
  - 同步的意思是当两个并发线程访问同一个类中的这个synchronized同步方法时，一个时间内只能有一个线程得到执行，另一个线程必须等待当前线程执行完才能执行，因此同步方法使得线程安全，保证了单例只有唯一个实例。
- 优缺点
  - 优点：解决了线程不安全的问题。
  - 缺点：效率有点低，每次调用实例都要判断同步锁，它的缺点在于每次调用getInstance（）都进行同步，造成了不必要的同步开销。这种模式一般不建议使用。
不过懒汉式的缺点也很明显
- 给 getInstance() 这个方法加了一把大锁（synchronzed），导致这个函数的并发度很低。量化一下的话，并发度是 1，也就相当于串行操作了。而这个函数是在单例使用期间，一直会被调用。如果这个单例类偶尔会被用到，那这种实现方式还可以接受。但是，如果频繁地用到，那频繁加锁、释放锁及并发度低等问题，会导致性能瓶颈，这种实现方式就不可取了。

04.双重DCL校验模式

饿汉式不支持延迟加载，懒汉式有性能问题，不支持高并发。那我们再来看一种既支持延迟加载、又支持高并发的单例实现方式，也就是双重检测实现方式。

在这种实现方式中，只要 instance 被创建之后，即便再调用 getInstance() 函数也不会再进入到加锁逻辑中了。所以，这种实现方式解决了懒汉式并发度低的问题。具体的代码实现如下所示：

public class Singleton {
    private static Singleton singleton;  //静态变量
    private Singleton (){}  //私有构造函数
    public static Singleton getInstance() {
        if (singleton == null) {  //第一层校验
            synchronized (Singleton.class) {
                if (singleton == null) {  //第二层校验
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

代码分析
- 这种模式的亮点在于getInstance（）方法上，其中对singleton 进行了两次判断是否空，第一层判断是为了避免不必要的同步，第二层的判断是为了在null的情况下才创建实例。
优缺点
- 优点：在并发量不多，安全性不高的情况下或许能很完美运行单例模式
- 缺点：不同平台编译过程中可能会存在严重安全隐患。
模拟分析
- 假设线程A执行到了singleton = new Singleton(); 语句，这里看起来是一句代码，但是它并不是一个原子操作，这句代码最终会被编译成多条汇编指令，它大致会做三件事情：
  - （a）给Singleton的实例分配内存
  - （b）调用Singleton（）的构造函数，初始化成员字段；
  - （c）将singleton对象指向分配的内存空间（即singleton不为空了）；
- 但是由于Java编译器允许处理器乱序执行，以及在jdk1.5之前，JMM（Java Memory Model：java内存模型）中Cache、寄存器、到主内存的回写顺序规定，上面的步骤b 步骤c的执行顺序是不保证了。也就是说执行顺序可能是a-b-c，也可能是a-c-b,如果是后者的指向顺序，并且恰恰在c执行完毕，b尚未执行时，被切换到线程B中，这时候因为singleton在线程A中执行了步骤c了，已经非空了，所以，线程B直接就取走了singleton，再使用时就会出错。这就是DCL失效问题。
- 但是在JDK1.5之后，官方给出了volatile关键字，将singleton定义的代码改成：private volatile static Singleton singleton; //使用volatile 关键字
网上有人说，这种实现方式有些问题。
- 因为指令重排序，可能会导致 singleton 对象被 new 出来，并且赋值给 instance 之后，还没来得及初始化（执行构造函数中的代码逻辑），就被另一个线程使用了。要解决这个问题，我们需要给 instance 成员变量加上 volatile 关键字，禁止指令重排序才行。实际上，只有很低版本的 Java 才会有这个问题。我们现在用的高版本的 Java 已经在 JDK 内部实现中解决了这个问题（解决的方法很简单，只要把对象 new 操作和初始化操作设计为原子操作，就自然能禁止重排序）。

05.静态内部类方式

再来看一种比双重检测更加简单的实现方法，那就是利用 Java 的静态内部类。它有点类似饿汉式，但又能做到了延迟加载。

public class Singleton {
    private Singleton (){} ;//私有的构造函数
    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    //定义的静态内部类
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();  //创建实例的地方
    }
}

优缺点
- 优点：延迟加载，线程安全（java中class加载时互斥的），也减少了内存消耗
代码分析
- 当第一次加载Singleton 类的时候并不会初始化INSTANCE ，只有第一次调用Singleton 的getInstance（）方法时才会导致INSTANCE 被初始化。
- 因此，第一次调用getInstance（）方法会导致虚拟机加载SingletonHolder 类，这种方式不仅能够确保单例对象的唯一性，同时也延迟了单例的实例化。

06.枚举方式单例

介绍一种最简单的实现方式，基于枚举类型的单例实现。这种实现方式通过 Java 枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性。具体的代码如下所示：
```
public enum Singleton {  //enum枚举类
    INSTANCE; 
    public void whateverMethod() { 

    } 
}
```
代码分析
- 枚举单例模式最大的优点就是写法简单，枚举在java中与普通的类是一样的，不仅能够有字段，还能够有自己的方法，最重要的是默认枚举实例是线程安全的，并且在任何情况下，它都是一个单例。即使是在反序列化的过程，枚举单例也不会重新生成新的实例。而其他几种方式，必须加入如下方法：才能保证反序列化时不会生成新的对象。
```
private Object readResolve()  throws ObjectStreamException{
    return INSTANCE;
}
```

07.容器实现单例模式

这一种比较少见，直接上代码，如下所示：

public class SingletonManager {
　　private static Map<String, Object> objMap = new HashMap<String,Object>();//使用HashMap作为缓存容器
    private Singleton() {
　　}
　　public static void registerService(String key, Object instance) {
　　　　if (!objMap.containsKey(key) ) {
　　　　　　objMap.put(key, instance) ;//第一次是存入Map
　　　　}
　　}
　　public static ObjectgetService(String key) {
　　　　return objMap.get(key) ;//返回与key相对应的对象
　　}
}

代码分析
- 在程序的初始，将多种单例模式注入到一个统一的管理类中，在使用时根据key获取对应类型的对象。

5.单例模式总结

总结：不管以哪种形式实现单例模式，它们的核心原理是将构造函数私有化，并且通过静态公有方法获取一个唯一的实例，在这个获取的过程中必须保证线程的安全，同时也要防止反序列化导致重新生成实例对象。
一般来说，单例模式有五种写法：懒汉、饿汉、双重检验锁、静态内部类、枚举。上述所说都是线程安全的实现，上文中第一种方式线程不安全，排除。
综合考虑：
- 推荐使用4.4 DCL双重校验模式，4.5 静态内部类单例模式等等
- 一般情况下直接使用饿汉式就好了，如果明确要求要懒加载（lazy initialization）倾向于使用静态内部类。如果涉及到反序列化创建对象时会试着使用枚举的方式来实现单例。
单例对象如果持有Context，那么很容易引发内存泄漏，此时要注意传递给单例对象的Context最好是Application Context