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

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

参考引用

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