单例模式可能是开发中应用最为广泛的一种的设计模式，Spring 中依赖注入 Bean 实例默认是单例的，在Netty开发的处理器很多也都是单例模式，另外许多的缓存数据持有者也是设置为单例模式，用上单例模式的好处是：1、可以保证内存里只有一个实例，减少了内存的开销。2、可以避免对资源的多重占用。3、单例模式设置全局访问点，可以优化和共享资源的访问。单例模式的特点，也是写单例代码的几个准则：
- 构造函数不对外开放，一般为private。
- 通过一个静态方法或者枚举返回单例类对象。
- 确保单例类的对象有且只有一个，尤其在多线程情况下。
- 确保单例类对象在反序列化时不会重新构建对象
首先看自己怎么写好一个单例模式，然后再来对照着看Spring的实现。
一、JDK的单例模式
1、饿汉式
这种是在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。
public class HungrySingleton
{
private static final HungrySingleton instance=new HungrySingleton();
private HungrySingleton(){}
public static HungrySingleton getInstance()
{
return instance;
}
}
2、懒汉式
该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。懒汉式的方式通常要考虑线程安全问题，为何呢？因为可能存在多个线程同时去调用 getlnstance 方法，而实例对象并未准备好需要去执行 new 操作。因此需要 Double Check Lock（DCL）双重校验锁来保证线程安全，第一层判断主要是为了判断是否存在，第二层判空是为了在null情况下创建实例。因此会有一个双重校验锁风格的代码：
//第一层判断主要是为了避免不必要的同步
if (instance == null) {
synchronized (Singleton.class) {
//第二层判空是为了在null情况下创建实例
if (instance == null) {
instance = new Singleton();
}
}
}
再来看new Singleton()操作并不是原子的，要分为三个步骤：
- 分配一块内存 M；
- 在内存 M 上初始化 Singleton 对象；
- 然后 M 的地址赋值给 instance 变量。
由于Java编译器允许处理器乱序执行，上述顺序2、3是不能保证的，可能是1-2-3也可能是1-3-2；如果是后者，3执行了已经非空，再走2会出现问题，这就是DCL失效（线程B刚好执行到第一次判断instance==null，此时不为空，不用进入synchronized里，就将还未初始化的instance返回了）。要解决的话只需要加上volatile关键字，如上述代码操作就可以保证instance对象每次都是从主内存中读取的，就可以采用DCL来完成单例模式了。当然，volatile或多或少会影响到性能，但考虑到程序的正确性，牺牲点性能还是值得的。
private volatile static DCLSingleton instance = null;
所以一个最终版的双重校验锁单例代码案例为：
public class DCLSingleton {
//Double Check Lock单例模式
private volatile static DCLSingleton instance = null;
private DCLSingleton() {
}
public static DCLSingleton getInstance() {
if (instance == null) {
synchronized (DCLSingleton.class) {
if (instance == null) {
instance = new DCLSingleton();
}
}
}
return instance;
}
}
3.反射和序列化攻击破坏单例
上面已经举例了恶汉、懒汉、DSL类型，当然还有静态内部类的实现方式，但是这些方法都有个共同的特点——私有的构造函数。这是为了防止在该类的外部直接调用构建函数创建对象了。但是该做法却无法防御反射攻击，比如我们可以通过反射拿到构造方法，通过调用 newInstance 方法进行破坏：
public class ReflectAttack {
public static void main(String[] args) throws Exception {
//获取无参的构造函数
Singleton instance = Singleton.getInstance();
//使用构造函数创建对象
Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
Singleton reflectInstance = constructor.newInstance();
System.out.println(instance==reflectInstance);
}
}
序列化攻击，先将得到的实例对象进行序列化得到字节数组，然后在进行反序列化就可以得到一个新的对象，这个对象已经和原来的对象不一样了。
public class DeserializeAttack {
public static void main(String[] args) throws Exception {
Singleton instance = Singleton.getInstance();
byte[] bytes = serialize(instance);
Object deserializeInstance = deserialize(bytes);
System.out.println(instance == deserializeInstance);//运行为false
}
private static byte[] serialize(Object object) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(object);
byte[] bytes = baos.toByteArray();
return bytes;
}
private static Object deserialize(byte[] bytes) throws Exception {
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
}
}
4.枚举单例
《Effective Java》中有被提到：单元素的枚举类型已经成为实现 Singleton 的最佳方法。为啥枚举能杜绝上面的反射和序列化攻击呢？1、在枚举中构造方法已被限制为私有，2、在调用构造方法时，我们的单例被实例化，enum中的实例被保证只会被实例化一次，所以我们的INSTANCE也被保证实例化一次。
class Resource{
}
public enum SomeThing {
/**
* 枚举实例默认就是final static类型
*/
INSTANCE;
private Resource instance;
/**
* 枚举的构造方法默认就是private的
*/
SomeThing() {
instance = new Resource();
}
public Resource getInstance() {
return instance;
}
}
二、Spring中的单例模式
Spring 依赖注入 Bean 实例默认是单例的。Spring 的依赖注入（包括 lazy-init 方式）都是发生在 AbstractBeanFactory 的 getBean 里。getBean 的 doGetBean 方法调用 getSingleton 进行 bean 的创建。
//AbstractBeanFactory#getSingleton()方法
public Object getSingleton(String beanName){
//参数true设置标识允许早期依赖
return getSingleton(beanName,true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//检查缓存中是否存在实例
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//如果为空，则锁定全局变量并进行处理。
synchronized (this.singletonObjects) {
//如果此bean正在加载，则不处理
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
//当某些方法需要提前初始化的时候则会调用addSingleFactory 方法
//将对应的ObjectFactory初始化策略存储在singletonFactories
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//调用预先设定的getObject方法
singletonObject = singletonFactory.getObject();
//记录在缓存中，earlysingletonObjects和singletonFactories互斥
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
spring 依赖注入时，可以看到是使用了 双重判断加锁的单例模式
