设计模式学习笔记（8）单例

本文实例代码：https://github.com/JamesZBL/java_design_patterns
单例（Singleton）模式是最常用的设计模式之一，但同时也是最能体现 Java 特性的设计模式之一，它是创建型模式中最经典的一个。
单例模式的核心目的是，保证一个类的实例只存在一个。许多场景中整个软件系统只需要拥有一个该类的全局对象，这是为了更好的实现这个对象的功能。一个常见的场景，服务器应用程序中，某些配置通常放在若干个文件中，某个类的一个单例对象将配置读取进来，以后每次需要获取配置信息只需要通过单例模式的风格获取这个对象，就能得到这些配置数据了。相反，如果每次需要获取配置信息都要 new 一个该类的对象并读取配置文件，那将造成许多本可以避免的性能开销。

实例

单例模式的应用场景理解起来比较简单，就不举具体的例子了，我们来看几种常用的单例写法：
先来看最简单的，这里的 Singleton类只是为了演示单例的写法，实际中它还应当实现某些功能：

public class Single {
    private static Single instance;
    public static Single getInstance() {
        if (instance == null) {
            instance = new Single();
        }
        return instance;
    }
}

这样写完后，每次需要获取 Singleton 类的实例，就调用 Singleton.getInstance() 这个方法。这样写对于一般的使用是可以了，但并不能完全保证 Singleton 类的对象只存在一个，因为我们可以手动调用 Singleton 类的构造方法来实例化出一个 Singleton 对象。那么如何避免这个问题呢？一个常用的方法就是将 Singleton 类的构造方法私有化，使得它的构造方法防止被外部的类调用，即只能由自己的静态方法实例化自己:

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

仔细看一下方法，每次获取实例对象之前先进行判空，如果对象为 null 则实例化一个 instance，如果存在则直接返回该实例。这种方法的看似是完美的，即看似实例只存在一个。但是，在多线程运行的时候，如果两个不同的线程同时运行到判空操作，会各自分别创建一个实例，这样一来，这种写法的使用结果就不是能保证单例了。
为了保证只有一个线程，需要引入一个关键字 synchronized，它的作用是给其修饰的方法加上一把同步锁，当访问带有这个关键字的方法时，其他访问该方法的线程都会进入阻塞状态：

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

虽然这样写可以保证该类的实例只存在一个，但是这会使得除了执行这个方法的线程顺利执行外，其他所有线程都要等待，这会造成极大的系统开销，降低了程序的运行效率。所以这种方法代价过高，因为无论 instance 是否为 null ,每次执行时，整个方法都加上了锁，我们不妨将锁的范围尽可能的缩小，把对性能的影响降到最低，于是有了如下写法：

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

这样，只有当判断 instance 为 null 的时候才执行内层的同步代码块，同步代码块中的判空保证了不会产生多个实例。这样看似没问题了，但是在计算机中，有时为了提高运行效率，会对指令进行重排，比如：

int a; //A
a = 3; //B
int b = 5; //C
int c = a + b; //D

可能会被重排成 A-C-B-D 或者 C-A-B-D，显然，重排之后是不影响程序最终的执行结果的，至于它究竟是如何提高运行效率的，我们暂时不考虑。回到 Singleton 的例子中， instance 对象势必会存在这样一种状态，即：已经为其分配了内存空间，但是并没有调用其构造方法进行实例化，就像上面代码中，语句 C 如果是判空，那么初始化就是语句 B，假如语句 C 赶在语句 B 之前执行了，a 确实不为空，但返回 a 一定会产生一个异常，因为它还没有被真正的初始化。
于是，诞生了终极写法 —— 引入 volatile 关键字：

public 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;
    }
}

volatile 关键字具有屏蔽指令重排的作用，即对 instance 加上了一把锁，在完成写操作之前不会允许其他线程对其进行任何读操作，即每次读取的内容都时实时的。因此，在初始化完成前，无法对其进行读操作，也就不会判断它是 null 了。
最后抛出一个神奇的方法，利用枚举类线程安全的特点，使用枚举类代替 class，这样使用起来不用考虑多线程的问题，是最方便的一种写法:

public enum Singleton {
    INSTANCE;
    //...
}

通过枚举类获取单例的实例：

Singleton result = Singleton.INSTANCE;

总结

单例模式写法的要点：
- 构造方法私有化
- 私有静态引用指向该类的实例
- 公有静态方法返回自己类的实例
单例模式的应用场景主要有：
- 一个类频繁的被实例化，但同时又频繁的被销毁
- 一个类的实例化过程非常耗费资源，且该类的对象频繁的被使用
- 类中的方法调用结果和类的状态有关
- 需要频繁访问网络、数据库或文件的类

个人博客同步更新，获取更多技术分享请关注：郑保乐的博客