设计模式系列：单例模式

作者持续关注WPS二次开发专题系列，持续为大家带来更多有价值的WPS开发技术细节，如果能够帮助到您，请帮忙来个一键三连，更多问题请联系我（WPS二次开发QQ群:250325397），摸鱼吹牛嗨起来！

定义

单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。

特点

单例类只有一个实例对象；
该单例对象必须由单例类自行创建；
单例类对外提供一个访问该单例的全局访问点。

使用场景

单例模式可以保证在一个 JVM 中只存在单一实例。单例模式的应用场景主要有以下几个方面。

需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC。
某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。
某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。
某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。
频繁访问数据库或文件的对象。
对于一些控制硬件级别的操作，或者从系统上来讲应当是单一控制逻辑的操作，如果有多个实例，则系统会完全乱套。
当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。

模式结构

单例模式的主要角色如下。

单例类：包含一个实例且能自行创建这个实例的类。
访问类：使用单例的类。

具体实现

(1) 饿汉式--（线程安全，实用）

/**
 * 单例模式--单例模式的饿汉式（线程安全，可用）
 * <pre>
 * (1)私有化该类的构造函数
 * (2)通过new在本类中创建一个本类对象
 * (3)定义一个公有的方法，将在该类中所创建的对象返回
 * 优点：从它的实现中我们可以看到，这种方式的实现比较简单，在类加载的时候就完成了实例化，避免了线程的同步问题。
 * 缺点：由于在类加载的时候就实例化了，所以没有达到Lazy Loading(懒加载)的效果，也就是说可能我没有用到这个实例，但是它
 * 也会加载，会造成内存的浪费(但是这个浪费可以忽略，所以这种方式也是推荐使用的)。
 * <pre>
 */
public class SingletonEHan {
    private static final SingletonEHan instance = new SingletonEHan();

    private SingletonEHan() {
    }

    private static SingletonEHan getInstance() {
        return instance;
    }
}

(2) 懒汉式--（线程安全，可用，效率稍低）

/**
 * 单例模式--懒汉式线程安全的:（线程安全，效率低，不推荐使用）
 * <pre>
 * 缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。
 * 而其实这个方法只执行一次实例化代码就够了，
 * 后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。
 * </pre>
 */
public class SingletonLanHan {
    private static SingletonLanHan instance = null;

    private SingletonLanHan() {
    }

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

(3) 懒汉式--双重校验锁（线程安全, 推荐）

/**
 * 单例模式--单例模式懒汉式双重校验锁（线程安全, 推荐）
 * <pre>
 * 懒汉式变种,属于懒汉式的最好写法,保证了:延迟加载和线程安全
 * </pre>
 */
public class SingletonDoubleCheck {
    private static volatile SingletonDoubleCheck instance = null;   //关键点0：声明单例对象是静态的

    private SingletonDoubleCheck() {                            //关键点1：构造函数是私有的
    }

    public static SingletonDoubleCheck getInstance() {          //通过静态方法来构造对象
        if (instance == null) {                                 //关键点2：判断单例对象是否已经被构造
            synchronized (SingletonDoubleCheck.class) {         //关键点3：加线程锁
                if (instance == null) {                         //关键点4：二次判断单例是否已经被构造
                    instance = new SingletonDoubleCheck();
                }
            }
        }
        return instance;
    }
}

注：instance加了volatile关键字来修饰，既然synchronized已经起到了多线程下原子性、有序性、可见性的作用，为什么还要加 volatile呢，主要原因如下：
a. 防止指令重排序
具体可见：单例模式与双重检测 - 设计模式 - Java - ITeye论坛

疑问：为什么instance要加volatile关键字来修饰?

解答：

****instance = new SingletonDoubleCheck();****分三步执行

①给 instance 分配内存

②调用 Singleton 的构造函数来初始化成员变量

③将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）。

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 ①-②-③ 也可能是 ①-③-②。如果是后者，则在 ③ 执行完毕、② 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。

由于 JVM 具有指令重排的特性，有可能执行顺序变为了 ① >③>②，具体如下：

public class SingletonDoubleCheck {
    private static SingletonDoubleCheck instance = null;

    private SingletonDoubleCheck() {
    }

    public static SingletonDoubleCheck getInstance() {
        if (instance == null) {    // B线程检测到instance不为空
            synchronized (SingletonDoubleCheck.class) {
                if (instance == null) {
                    instance = new SingletonDoubleCheck();    // A线程被指令重排了，刚好先赋值了；但还没执行完构造函数。
                }
            }
        }
        return instance;    // 后面B线程执行时将引发：对象尚未初始化错误。
    }
}

使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。 也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 ①-②-③ 之后或者 ①-③-② 之后，不存在执行到 ①-③ 然后取到值的情况。

(4) 静态内部类--（线程安全，推荐）

/**
 * 单例模式--内部类（线程安全，推荐）
 * <pre>
 * 这种方式跟饿汉式方式采用的机制类似，但又有不同。
 * 两者都是采用了类装载的机制来保证初始化实例时只有一个线程。
 * 不同的地方:
 * 在饿汉式方式是只要Singleton类被装载就会实例化,
 * 内部类是在需要实例化时，调用getInstance方法，才会装载SingletonHolder类
 * 优点：避免了线程不安全，延迟加载，效率高。
 * <pre>
 */
public class SingletonLazy {

    private SingletonLazy() {
    }

    private static class SingletonHolder {
        private static final SingletonLazy INSTANCE = new SingletonLazy();
    }

    public static SingletonLazy getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

(5) 枚举--（线程安全，推荐）

/**
 * 单例模式--枚举（线程安全，可用）
 * <pre>
 * 这里SingletonEnum.instance
 * 这里的instance即为SingletonEnum类型的引用所以得到它就可以调用枚举中的方法了。
 * 借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
 * </pre>
 */
public enum SingletonEnum {
    INSTANCE;

    public static void main(String[] args) {
        SingletonEnum obj = SingletonEnum.INSTANCE;
        System.out.println(obj);
    }
}