设计模式寻根究底 - 单例模式（Singleton）

原创-转载请注明：https://zhangzhaoyu.github.io/2016/10/08/introduction-of-singleton-design-pattern/

概述

单例模式是一个既简单又复杂的模式。简单在它想实现的目标十分容易理解，而又复杂在要写出线程安全的单例模式不是那么容易。单例模式的核心定义是：确保某个类只有一个实例，并提供一个访问该实例的全局访问点(Ensure a class has only instance, and provide a global point of access to it)。

单例模式的实现

单例模式的实现分为急切的（Eager）和延迟的(Lazy)，线程安全(Thread-Safe)和非线程安全(Non-Thread-Safe)几种。下面就Java 对单例模式的实现进行介绍。

Eager 模式实现

Eager 模式的实现通常在静态的单例字段声明时（或单例类的构造函数）就创建该单例的对象。这样在单例类被Java 虚拟机加载时，就能够实例化该单例。

基于静态域的Eager 模式

public class StaticSingleton implements Serializable {    private static StaticSingleton INSTANCE = new StaticSingleton();    private StaticSingleton() {}    public static StaticSingleton getInstance() {        return INSTANCE;    }    /**     * 解决反序列化出现多个实例的问题     * @return     */    private Object readResolve() {        return INSTANCE;    }}

将初始化放到静态块中实现

public class Singleton {      private Singleton instance = null;      static {          instance = new Singleton();      }      private Singleton (){}      public static Singleton getInstance() {          return this.instance;      }  } 

基Java Enum 实现的Eager 模式

Java 枚举模式实现的单例是被推崇的，因为其具有：

• 绝对的线程安全的，由Java 虚拟机保证
• 不会因为反序列化产生对个实例，Enum 在底层实现了readResolve() 方法
• 由于Enum 类型在Java 底层是由abstract 修饰的类，因此没法被实例化，能够防止反射攻击。因为反射机制可以调用私有的构造器构造对象

public enum  EnumSingleton {    INSTANCE;    private Object singleton;    public void print(String name) {        System.out.println("Hello : " + name);    }    public Object build() {        singleton = new Object();        return singleton;    }}class Client {    public static void main(String[] args) {        EnumSingleton.INSTANCE.print("hello");        Object object = EnumSingleton.INSTANCE.build();    }}

Lazy 模式实现

Eager 模式的实现可以避免线程的问题，但是当单例对象需要加载的系统资源很多时，会导致系统在启动时很慢。因此，需要一种方式在使用该对象时构造。也就是单例实现的Lazy 模式。

非线程安全的Lazy 模式

采用延迟实例化的方式，能够将单例对象的构造延迟到第一次调用时。很显然，该方式是非线程安全（Non-Thread-Safe）的。

public class Singleton {          private static Singleton singleton = null;          private Singleton() {}          public static Singleton getSingleton() {              if (singleton == null) {                  // can be interrupted to other thread                singleton = new Singleton();              }              return singleton;          }      }

线程安全的Lazy 模式

在方法上加锁，能够保证该单例模式在多线程环境下的安全性，但是性能将严重受到影响。因为单例对象一旦创建就不需要同步读取获得对象上的互斥锁。

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

基于静态内部类的方式

内部静态类SingletonHolder 不会在Singleton 类被装载时就被实例化，需要在getInstance() 显示地被调用时才会被加载。因此，也可以实现Lazy 加载。

public class Singleton {      private static class SingletonHolder {      private static final Singleton INSTANCE = new Singleton();      }      private Singleton (){}      public static final Singleton getInstance() {          return SingletonHolder.INSTANCE;      }  }  

基于DCL 的Lazy 模式

DCL（Double Checked Locking）配合volatile 的使用进行双重检查，能够满足线程安全和延迟加载。

/** Lazy load thread safe * Created by zhaoyu on 16-8-31. */public class DoubleCheckedLockingSingleton {    private volatile DoubleCheckedLockingSingleton INSTANCE;    private DoubleCheckedLockingSingleton() {}    public DoubleCheckedLockingSingleton getInstance() {        if (INSTANCE == null) {            synchronized (DoubleCheckedLockingSingleton.class) {                if (INSTANCE == null) {                    INSTANCE = new DoubleCheckedLockingSingleton();                }            }        }        return INSTANCE;    }}

单例模式的使用场景

• 项目中共享的访问点或共享的数据，如系统的配置信息
• 创建一个系统消耗过多资源的对象，例如访问IO和数据库等资源
• Web 中采用单例模式保持计数器的值，并确保是线程安全的
• 生成唯一的序列ID 的场景

总结

单例模式（Singleton Pattern）作为被广泛使用的一个模式，不仅能够减少系统的内存开销和提高系统的性能，还能够避免对系统资源的过多占用。在使用单例模式时一定要考虑是否在多线程环境下使用。目前，基于Enum 的实现是现在推荐的单例实现方式。总之，单例模式的使用需要在实际环境中根据需求选择合适的实现方式。

参考引用

1. 单例模式
2. 设计模式-单例模式-TRAMP_ZZY