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

推荐阅读更多精彩内容