Singleton 单例模式

动机

有些情况下，一个类只能有一个实例是很重要的。比如说，在操作系统中只能有一个窗口管理器的（文件系统或打印机程序）。通常， 单实例用于对内部或外部资源的集中式管理，同时它们提供一个访问其自身的全局入口。

单例模式是最简单的设计模式之一。它只涉及到一个负责实例化它自己的类，这个类保证其只创建一个实例（私有化构造函数）；同时该类提供一个访问该实例的全局入口。这样，程序各处都使用同一实例，不会每次都直接调用构造函数。

目的

• 确保一个类只创建一个实例
• 提供访问该单一实例的全局入口

实现

具体实现涉及 Singleton 类的一个静态私有成员，一个私有构造函数和一个共有方法返回该静态私有成员的引用。

单例实现 uml

单例模式定义一个 getInstance 方法来暴露供客户端访问的单一实例。getInstance() 负责在单一实例还没被创建的时候创建它并返回该实例。

class Singleton{
    private static Singleton instance;
    private Singleton(){
        // ...
    }

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

    public void doSomething(){
        //...
    }
}

你可以发现上面的代码 getInstance 方法确保只创建一个类实例。不能从类的外部访问构造函数以保证只能通过 getIntance 方法来创建类实例。

getInstance 方法也作为对象唯一的全局访问入口，可以像下面这样使用：

Singleton.getInstance().doSomething();

适用场景 & 例子

根据定义，单例模式的使用场景应该是一个类必须只有一个实例，并且必须从一个全局入口访问这个实例。以下几个是使用单例模式的真实案例：

• 日志类 Logger Classes
  单例模式被用于日志类的设计中。 这些日志类通常以单例来实现，并且在应用各组件中提供一个全局的日志记录入口，执行日志记录操作时就不用每次都创建对象了。
• 配置类 Configuration Classes
  使用单例模式设计为应用提供配置的类。通过将配置类实现为单例，不单单提供全局访问入口，我们还可以将这个实例作为缓存对象。当实例化类的时候（读取值），单例会将值保持在其内部结构中。如果配置是从数据库或者文件中读取，这样就不用每次使用配置参数时都要去重新载入值了。
• 共享地访问资源
  单例模式可以用于设计需要串行运行的应用。假设应用中有许多在多线程环境中运行的类，这些类需要串行地执行操作。在这种情况下， 带有 synchronized 方法的单例实例就可以用来管理这些串行操作。
• 单例实现的工厂
  假设我们设计一个执行于多线程环境下的应用，其中有一个用于生成带有id的新对象（账户，客户，网站，地址等对象）。如果这工厂类在2个不同的线程中实例化2次，那么就可能出现id重叠的2个不同对象。如果我们将这个 Factory 实现为一个单例就可以避免这个问题。通常将 抽象工厂 或 工厂方法 同 单例模式 一起使用。

特定的问题和实现

为了在多线程下使用，线程安全的实现

一个健壮的单例实现应该在任何情况下都能正常工作。这就是为什么我们要确保多线程使用时它也能正常工作的原因。如前面例子的单例确保读写操作都是同步的，它可用于多线程应用中。

一、 使用双重锁定机制实现延迟初始化（懒汉）

上面代码中展示的标准实现是一种线程安全的实现，但它不是最好的线程安全实现，因为当我们考虑性能时，同步操作的开销比较大。我们能看出同步的 getInstance 在实例已经创建后并不需要再进行同步。如果我们发现实例已经创建，我们只需返回这个实例，而不需要使用任何同步代码块。这个优化在于在非同步代码块中检查实例是否为 null， 再在同步代码块中检验是否 null 并且创建实例。这称为双重锁定机制。

在这种情况下，单例实例在第一次调用 getInstance() 方法的时候创建。这就叫延迟初始化，并且它确保这个单例的实例只在需要的时候创建。

// 使用双重锁定机制的延迟初始化
class Singleton{
    private static volatile Singleton instance; 

    private Singleton(){}

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

    public void doSomething(){
         // ...
    }
}

关于为什么要加 volatile 可以参考下 https://www.ibm.com/developerworks/cn/java/j-jtp06197.html

二、 使用静态字段实现预先加载 （饿汉）

由于以下实现中单例实例被声明为静态成员了，在类加载的时候就实例化了而不是第一次使用它的时候。这就是为什么我们不再需要同步代码了。 类只加载一次保证实例的唯一性。

class Singleton{
    private static Singleton instance = new Singleton();

    private Singleton() {
         //...
    }

    public static Singleton getInstance(){
        return instance;
    }

    public void doSomething(){
        //...
    }
}

protected constructor

可以使用 protected 访问修饰符的构造函数来授权给子类。但是这种技术有2个缺陷，使得单例的继承不切实际：

• 首先，如果构造函数是 protected， 意味着这个类可以被同一个包内的其他类实例化。可能的措施是隔离单例类。
• 其次，要使用派生类，所有的 getInstance 调用都得从现有代码中的 Singleton.getInstance() 改为 NewSingleton.getInstance()

如果多个 classloader 访问同一个单例类，会有多个单例实例

如果一个类（相同类名，相同包名）被2个不同的 classloader 加载，那么他们代表内存中2个不同的类。

序列化

如果单例类实现了 java.io.Serializable 接口，当单例实例被序列化和反序列化多次时，就会创建多个单例类实例。为了避免这种情况，必须实现 readResolve 方法。 参考下 Serializable () 和 readResolve 方法的说明。

将 抽象工厂 和 工厂方法 实现为单例

在一些特定的场景下工厂必须是唯一的。存在2个工厂的话，创建对象时会有意料之外的影响。为了确保工厂的唯一性，它要实现成单例。这样做之后我们也避免了使用前的工厂实例化。

Hot Spot:

• 多线程： 当单例运行于多线程应用时，必须格外小心
• 序列化： 当单例类实现了 Serializable 接口，它们必须实现 readResolve 方法以避免 2 个不同的对象
• Classloaders 如果单例类被2个不同的类加载器加载，我们将得到2个不同类，一个类加载器一个
• 由类名表示的全局访问入口：单例类的实例通过类名来获取。乍一看，这样很容易访问实例，但这不是很灵活。如果我们要替换这个单例类，就要修改代码中所有的引用。

jdk 中的使用

**
 * Every Java application has a single instance of class
 * <code>Runtime</code> that allows the application to interface with
 * the environment in which the application is running. The current
 * runtime can be obtained from the <code>getRuntime</code> method.
 * <p>
 * An application cannot create its own instance of this class.
 *
 * @author  unascribed
 * @see     java.lang.Runtime#getRuntime()
 * @since   JDK1.0
 */
public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}

    // ...
}

more
示例代码：https://github.com/minorpoet/design-patterns/tree/master/Singleton
classloader: http://ifeve.com/classloader/
volatile: http://www.jianshu.com/p/3893fb35240f
double-check-lock is broken: http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html