原创-转载请注明 http://tramp.cincout.cn/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 的实现是现在推荐的单例实现方式。总之，单例模式的使用需要在实际环境中根据需求选择合适的实现方式。
