单例模式

单例模式（Singleton Pattern）

单例模式是结构最简单的设计模式，在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以确保系统中的一个类只有一个实例而且该实例易于被外界访问，从而方便对实例个数进行控制，节约系统资源。

单例模式概述

对于一个软件系统中的某些类而言，只有一个实例很重要。例如Windows中的窗口管理器窗口，如果不使用机制对窗口对象进行唯一化，势必会弹出多个窗口。如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着某一瞬间系统有多个状态，与实际不符，也使用户无法明确哪一个才是真实的状态。

如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个统一的全局变量可以确保对象随时都可以被访问，但不能防止创建多个对象。一个更好的解决方法是让类自身负责创建和保存它的唯一实例，并保证不能创建其他实例，它还提供一个访问该实例的方法，这就是单例模式的动机。

定义：确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。

单例模式是一种对象创建型模式。单例模式有3个要点：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

单例模式结构与实现

单例模式结构

单例模式是结构最简单的设计模式，它只包含一个类，即单例类。结构图如下：

由图可知，单例模式只包含一个单例角色，也就是Singleton。

对于Singleton（单例），在单例类的内部创建它的唯一实例，并通过静态方法getInstance()让客户端可以使用它的唯一实例；为了防止在外部对单例类实例化，将其构造函数的可见性设为private；在单例类内部定义了一个Singleton类型的静态对象作为供外部共享访问的唯一实例。

单例模式实现

单例模式的目的是保证一个类有且仅有一个实例，并提供一个访问它的全局访问点。单例模式包含的角色只有一个，也就是单例类Singleton。单例类拥有一个私有构造函数，确保用户无法通过new关键字直接实例化它。除此之外，在单例类中还包含了一个静态私有成员变量与静态公有的工厂方法，该工厂方法负责检验实例的存在性并实例化自己，然后存储在静态成员变量中，以确保只有一个实例被创建。

通常，单例模式的实现代码如下：

public class Singleton {
    private static Singleton instance = null;//静态私有成员变量
    
    //私有构造函数
    private Singleton() {
    }
    
    //静态公有工厂方法，返回唯一实例
    public static Singleton getInstance() {
        if(instance == null)
            instance = new Singleton();
        return instance;
    }
}

在单例模式的实现过程中需要注意以下3点：

1. 单例类构造函数的可见性为private。
2. 提供一个类型为自身的静态私有成员变量。
3. 提供一个公有的静态工厂方法。

饿汉式单例与懒汉式单例

饿汉式单例类

饿汉式单例类（Eager Singleton）是实现起来最简单的单例类，饿汉式单例类结构图如下：

从图可看出，由于在定义静态变量的时候实例化单例类，因此在类加载时单例对象就已创建，代码如下：

public class EagerSingleton {
    private static final EagerSingleton instance = new EagerSingleton();
    private EagerSingleton() {}
    
    public static EagerSingleton getInstance() {
        return instance;
    }
}

当类被加载时，静态变量instance会被初始化，此时类的私有构造函数会被调用，单例类的唯一实例将被创建。

懒汉式单例类与双重检查锁定

与饿汉式单例类相同的是，懒汉式单例类（Lazy Singleton）的构造函数也是私有的。与饿汉式单例类不同的是，懒汉式单例类在第一次被引用时将自己实例化，在懒汉式单例类被加载时不会将自己实例化。懒汉式单例类的结构图如下图：

从图可看出，懒汉式单例在第一次调用getInstance()方法时实例化，在类加载时并不实例化，这种技术又称为延迟加载（Lazy Load）技术，即需要的时候再加载实例。为了避免多个线程同时调用getInstance()方法，可以使用关键字synchronized，代码如下：

public class LazySingleton {
    private static LazySingleton instance = null;
    
    private LazySingleton() {}
    
    //使用synchronized关键字对方法加锁，确保任意时刻只有一个线程可执行该方法
    synchronized public static LazySingleton getInstance() {
        if(instance == null)
            instance = new LazySingleton();
        return instance;
    }
}

在上述懒汉式单例中，在getInstance()方法前面加了关键字synchronized进行线程锁定，以处理多个线程同时访问的问题。上述代码虽然解决了线程安全问题，但是每次调用getInstance()时都需要进行线程锁定判断，在多线程高并发访问环境中将会导致系统性能大大降低。因此可以继续对懒汉式单例进行改进，通过分析不难发现无须对整个getInstance()方法进行锁定，只需对其中的代码“instance = new LazySingleton();"进行锁定即可。getInstance()方法可以进行如下改进：

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

问题貌似解决，事实并非如此。如果使用以上代码来实现单例类，还是会存在单例对象不唯一的情况。原因如下：

假如在某一瞬间线程A和线程B都在调用getInstance()方法，此时instance对象为null值，均能通过if判断条件。由于实现了synchronized加锁机制，线程A进入synchronized锁定的代码中执行实例创建代码，线程B处于排队等待状态，必须等待线程A执行完毕后才可以进入synchronized锁定的代码。但当A执行完毕时线程B并不知道实例已经创建，将继续创建新的实例，导致产生多个单例对象，违背了单例模式的设计思想，因此需要进一步改进，在synchronized中再进行一次”instance==null“；判断，这种方式称为双重检查锁定（Double-Check Locking）。使用双重检查锁定实现的懒汉式单例类的完整代码如下：

public class LazySingleton {
    private volatile static LazySingleton instance = null;
    
    private LazySingleton() {}
    
    public static LazySingleton getInstance() {
        //第一重判断
        if(instance == null) {
            //锁定代码块
            synchronized(LazySingleton.class) {
                //第二重判断
                if(instance == null) {
            		instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

需要注意的是，如果使用双重检查锁定来实现懒汉式单例类，需要在静态成员变量instance之前增加修饰符volatile，被volatile修饰的成员变量可以确保多个线程都能够正确处理，且该代码只能在JDK1.5及以上版本中才能正确执行。由于volatile关键字会屏蔽Java虚拟机所作的一些代码优化，可能会导致系统的运行效率降低，因此即使使用双重检查锁定来实现单例模式也不是一种完美的实现方式。

饿汉式单例类与懒汉式单例类的比较

饿汉式单例类在类被加载时就将自己实例化，它的优点在于无须考虑多个线程同时访问的问题，可以确保实例的唯一性；从调用速度和反应时间角度来讲，由于单例对象一开始就得以创建，因此要由于懒汉式单例。但是无论系统在运行时是否需要使用该单例对象，由于在类加载时该对象就需要创建，因此从资源利用效率角度来讲饿汉式单例不及懒汉式单例，而且在系统加载时由于需要创建饿汉式单例对象，加载时间可能会比较长。

懒汉式单例类在第一次使用时创建，无须一直占用系统资源，实现了延迟加载，但是必须处理多个线程同时访问的问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费大量时间，这意味着出现多线程同时首次引用此类的几率变得较大，需要通过双重检查锁定等机制进行控制，这将导致系统性能受到一定影响。

使用静态内部类实现单例模式

饿汉式单例类不能实现延迟加载，不管将来用不用始终占据内存；懒汉式单例类线程安全控制烦琐，而且性能受影响。可见。两种以上单例模式都存在一定问题。为了克服这些问题，在Java语言中可以通过Initialization on Demand Holder（IoDH）技术来实现单例模式。

在IoDH中，需要在单例类中增加一个静态（static）内部类，在该内部类中创建单例对象，再将该单例对象通过getInstance()方法返回给外部使用，代码如下：

//Initialization on Demand Holder（IoDH）
public class Singleton {
    private Singleton() {}
    
    //静态内部类
    private static class HolderClass {
        private final static Singleton instance = new Singleton();
    }
    
    public static Singleton getInstance() {
        return HolderClass.instance;
    }
}

由于静态单例对象没有作为Singleton的成员变量直接实例化，因此类加载时不会实例化Singleton，第一次调用getInstance()时将加载内部类HolderClass，在该内部类中定义了一个static类型的变量instance，此时会首先初始化这个成员变量，由Java虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定，因此其性能不会造成任何影响。

通过使用IoDH既可以实现延迟加载，又可以保证线程安全，不影响系统性能，不失为一种最好的Java语言单例模式实现方式；其缺点是与编程语言本身的特性相关，很多面向对象语言不支持IoDH。

单例模式优/缺点与适用环境

优点

1. 单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。
2. 由于在系统中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能。
3. 允许可变数目的实例。基于单例模式可以进行扩展，使用与控制单例对象相似的方法来获得指定个数的实例对象，既节省资源，又解决了由于单例对象共享过多有损性能的问题。（注：自行提供指定数目实例对象的类可称为多例类）

缺点

1. 由于单例模式中没有抽象层，因此单例类的扩展有很大的麻烦。
2. 单例类的职责过重，在一定程度上违背了单一职责原则。因为单例类提供了业务方法，又提供了创建对象的方法（工厂方法），将对象的创建和对象本身的功能耦合在一起。
3. 如Java、C#等面向对象语言的运行环境都提供了自动垃圾回收技术，因此如果实例化的共享对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这样导致共享的单例对象状态丢失。

适用环境

1. 系统只需要一个实例对象，例如系统要求提供一个唯一的序列号生成器或资源管理器，或者因为资源消耗太大而只允许创建一个对象。
2. 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该例。