设计模式系列之单例模式

共计 6248 个字符，预计需要花费 16 分钟才能阅读完成。

本文循序渐进介绍单例模式的几种实现方式，以及 Jdk 中使用到单例模式的例子，以及 sring 框架中使用到的单例模式例子。

package signgleton;

/**
 * 单例模式简单的实现
 */
public class Singleton {private static Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {return instance;}

}

”饿汉式“只是形象的比喻，因为他想要这个实例的时候，不需要等待，别废话，给哥拿来。通过 static 的初始化方式，借助类第一次被加载时，就把 Singleton 实例给创建出来了，并存储在 JVM 的方法区，属于类变量，被所有的实例共享。不同的线程调用都返回一个实例，所以这样也保证了线程安全。

它还有个孪生兄弟，静态代码块来实例化：

package signgleton;

/**
 * 通过静态代码块创建实例对象
 */
public class StaticSignleton {

    private static StaticSignleton instance;

    /**
     * 静态代码块创建实例
     */
    static {instance = new StaticSignleton();
    }
    
    private StaticSignleton() {}
    public static StaticSignleton getInstance() {return instance;}
}

科普一下类初始化顺序：

静态变量、静态代码块初始化
构造函数
自定义构造函数

饿汉式缺点：因为在类被加载的时候对象就会被实例化，这可能会造成不必要的消耗，如果你的程序不在乎这点消耗那就当我没说。

下面介绍两种方式解决上面的问题：第一是使用静态内部类，第二是使用懒汉式

package signgleton;

/**
 * 使用静态内部类获取单例实例
 */
public class StaticInnerClassSingleton {
    
    private static class InnerSingletonClass{private static final StaticInnerClassSingleton innerInstance = new StaticInnerClassSingleton();
        
    }
    private StaticInnerClassSingleton() {}
    public static final StaticInnerClassSingleton getStaticInstance() {return InnerSingletonClass.innerInstance;}
}

静态内部类同样借助了 JVM 这个大佬来保证线程安全，只是他在类加载的时候并没有立即实例化对象，而是采用了延迟加载策略，只有调用 getStaticInstance 的时候才用内部类去创建实例

package signgleton;

/**
 * 线程不安全的懒汉式
 */
public class UnsafeSingleton {
    
    private static UnsafeSingleton unsafeSingleton;
    private UnsafeSingleton() {}
    public static UnsafeSingleton getUnsafeSingleton() {if (unsafeSingleton == null) {unsafeSingleton = new UnsafeSingleton();
        }
        return unsafeSingleton;
    }
    
}

虽然这样写达到了使用的时候才实例化的目的，但是也带来的线程安全问题。在多线程下，可能有两个以上的线程同时进入 if(unsafeInstance == null)，这样会发生一些奇怪不定的结果。

package signgleton;

/**
 * 线程安全的懒汉式
 */
public class SafeSingleton {
    private static SafeSingleton safeSingleton;
    private SafeSingleton() {}
    public static synchronized SafeSingleton getSafeSingleton() {if (safeSingleton == null) {safeSingleton = new SafeSingleton();
        }
        return safeSingleton;
    }
}

这种方式在方法上加 synchronized 同步关键字解决了饿汉式线程安全问题，但是因为每次调用都加锁，极大地降低了性能，因为只有第一次创建实例时需要加锁，弄成现在每次都加锁。有没有解决办法呢，当然有，前辈们都是很聪明的，想出了双重校验锁这个经典的例子.

package signgleton;

/**
 * 线程不安全双重校验锁
 */
public class UnSafeTwoCheckSingleton {
    private static UnSafeTwoCheckSingleton singleton;
    private UnSafeTwoCheckSingleton() {}
    public static UnSafeTwoCheckSingleton getSingleton() {if (singleton == null) {synchronized (UnSafeTwoCheckSingleton.class) {if (singleton == null) {singleton = new UnSafeTwoCheckSingleton();
                }
            }
        }
        return singleton;
    }
}

双重校验锁的形式主要是缩小了锁的范围，但是熟悉多线程编程的同学就可以看得出来，即使这样做还是有线程安全问题，这里存在一个多个线程共享变量的可见性问题（这部分我不太懂原理），解决方案就是使用 volatile

使用 volatile 优化

package signgleton;

/**
 * 线程安全双重校验锁
 */
public class SafeTwoCheckSingleton {
    private static volatile SafeTwoCheckSingleton singleton;
    private SafeTwoCheckSingleton() {}
    public static SafeTwoCheckSingleton getSingleton() {if (singleton == null) {synchronized (SafeTwoCheckSingleton.class) {if (singleton == null) {singleton = new SafeTwoCheckSingleton();
                }
            }
        }
        return singleton;
    }
}

你以为这样就安全了吗，就想下班了吗？还没完，序列化这个恶棍会破坏单例，防范序列化这个恶棍破坏单例，可以在类中定义我们获取实例的策略，既加 readResolve。

package signgleton;

import java.io.Serializable;

/**
 * 线程安全双重校验锁
 */
public class SafeTwoCheckSingleton implements Serializable{
    private static volatile SafeTwoCheckSingleton singleton;
    private SafeTwoCheckSingleton() {}
    public static SafeTwoCheckSingleton getSingleton() {if (singleton == null) {synchronized (SafeTwoCheckSingleton.class) {if (singleton == null) {singleton = new SafeTwoCheckSingleton();
                }
            }
        }
        return singleton;
    }
    
    private Object readResolve() {return singleton;}
}

这么多的实现方式，你会问，有什么用？用处可大了，下面讲两个使用实例，一个 jdk 的 Runtime, 一个是 Spring 框架中的单例模式。

Runtime：是一个封装了 JVM 进程的类，每一个 JAVA 程序实际上都是 JVM 的一个进程，每一个进程都是对应这么一个 Runtime 实例。
源码如下：

public class Runtime {private static Runtime currentRuntime = new Runtime();


        public static Runtime getRuntime() {return currentRuntime;}
        private Runtime() {}
    }

这里使用了饿汉式单例模式。

下面我们来看看看 spring 中的单例模式，spring 中使用的是单例注册表的特殊方式实现的单例模式，所以说模式是死的，需要灵活得运用。

看看单例注册表的实现原理 demo:

package signgleton;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 单例注册表 demo
 */
public class SingletonRegTest {private final static Map<String, Object> singletonObjects = new ConcurrentHashMap<String,Object>();

    /**
     * 类加载时初始化一个实例
     */
    static {SingletonRegTest singletonRegTest = new SingletonRegTest();
        singletonObjects.put(singletonRegTest.getClass().getName(), singletonRegTest);
    }

    public static SingletonRegTest getInstance(String name) {if (name == null) {
            // 默认分配一个实例
            name = "signgleton.SingletonRegTest";
        }
        if (singletonObjects.get(name) == null) {
            try {
                // 将默认实例放入缓存中
                singletonObjects.put(name, Class.forName(name).newInstance());
            } catch (Exception ex) {ex.printStackTrace();
            }
        }
        return (SingletonRegTest) singletonObjects.get(name);
    }
}

再来看看 spring 源码：

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {@SuppressWarnings("unchecked")
    protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {final String beanName = transformedBeanName(name);
        Object bean;
        // 从单例注册表中检查是否存在单例缓存
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            ...
            // 返回缓存实例
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        else {
            ...
            try {
                 ...

                // 如果是单例模式
                if (mbd.isSingleton()) {sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            try {return createBean(beanName, mbd, args);
                            }
                            catch (BeansException ex) {...}
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
                // 如果是原型模式
                else if (mbd.isPrototype()) {...}
                // 其他模式
                else {...}
            }
            catch (BeansException ex) {...}
        }
        return (T) bean;
    }
}

我们进入 getSingleton() 方法：

import java.util.Map;

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    // 通过 ConcurrentHashMap 实现单例注册表
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64);

    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(beanName, "'beanName' must not be null");
        synchronized (this.singletonObjects) {
            // 检查缓存中是否存在实例  
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                ...
                try {singletonObject = singletonFactory.getObject();
                }
                catch (BeanCreationException ex) {...}
                finally {...}
                // 如果实例对象在不存在，我们注册到单例注册表中。addSingleton(beanName, singletonObject);
            }
            return (singletonObject != NULL_OBJECT ? singletonObject : null);
        }
    }

    protected void addSingleton(String beanName, Object singletonObject) {synchronized (this.singletonObjects) {this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));

        }
    }
}

是不是和我们的单例注册表 demo 很相似。
单例模式的讲解后面随着学习到其他框架再做相应的补充，也欢迎大家献言献策。

饿汉式

静态内部类

线程不安全的懒汉式

线程安全的懒汉式

双重校验锁

防范序列化破坏单例

单例模式案例

Just My Socks（注册教程内含优惠码）