设计模式——单例模式

引言

今天来谈谈设计模式中的单例模式，温故知新，以免生疏。

软件设计领域的四位世界级大师Gang Of Four (GoF)：Erich Gamma，Richard Helm，Ralph Johnson，John Vlissides四人合著了《Design Patterns – Elements of Reusable Object-Oriented Software》一书，（中文译名：《设计模式:可复用面向对象软件的基础》）。该书首次提到了软件开发中 设计模式 的概念，对面向对象软件设计产生了巨大影响。

• *创建型模式

单例模式属于创建型模式，那么这里就要简述一下创建型模式。顾名思义，就是创建对象的设计模式。频繁地使用基本对象创建方式（比如new操作）会使系统的耦合性变高，导致某些设计上的问题。创建型模式对类的实例化进行抽象，将对象的创建与对象的使用分离，隐藏了类的实例化过程。

• *单例模式的由来

在系统中，有一些对象其实只需要一个，例如线程池、缓存、注册表、日志对象、充当打印机显卡等设备驱动程序的对象。同时这些类比较庞大复杂，并且这些对象完全可以复用。若创建多个实例或频繁创建销毁实例对象，会导致程序行为异常、资源使用过量、或者不一致性的结果，这就有了单例模式。

• 单例模式含义 确保一个类只有一个实例，并提供该实例的全局访问点，后半句通俗点讲，就是向整个系统提供这个实例。

类的构成

• 构造函数： private Singleton(){}，私有。因为一个类只能有一个实例，不可被外部再次实例化，构造方法不可能是 public，只能是 private。保证了不能通过构造器进行创建实例对象。
• (成员)变量： private static Singleton instance，私有，静态变量。由于类中仅有一个实例，属于当前类的静态变量，外部无法直接访问。
• 方法： public static Singleton getInstance(){}，公有，静态方法。要向整个系统提供该单例，就要创建一个公有的静态方法向外界提供当前类的实例。

实现方式

1. 懒汉式(线程不安全)

• 描述：这是最基本的实现方式，实例对象在第一次被调用的时候才会被创建，属于懒加载，延迟创建单例。
• 优点：懒加载模式下，如果没有使用到该类，那么就不会实例化对象，节约了资源。
• 缺点：这种实现方式 不支持多线程，这是最主要的问题，因为没有加锁 synchronized， 无法实现线程安全。在执行 if (Instance == null)时， 如果多个线程同时进入，并且此时 Instance 为 null，那么这些线程就会在执行 new语句， 导致多次实例化对象，这是我们不希望看到的。

public class Singleton {
    private static Singleton instance;  //声明静态变量
    private Singleton (){}   //构造器

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

2. 懒汉式(线程安全)

• 描述：实例对象在也是第一次被调用的时候才会被创建，属于懒加载，通过静态同步方法解决线程安全问题。
• 优点：懒加载，节约内存资源。使用同步方法，在某个时间点只能有一个线程能够进入方法，避免了多次实例化的问题，因此支持多线程，保证了线程安全。
• 缺点：我们希望在创建实例的时间点进行加锁同步，用静态同步方法会使得同步的范围太大，另外每次要创建对象都要 争抢锁，未进入方法的线程必须 等待， 性能会有损耗，效率不高。

public class Singleton {
    private static Singleton instance;
    private Singleton (){}
    public static synchronized Singleton getInstance() {  //使用同步方法
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

3. 饿汉式(线程安全)

• 描述：线程不安全问题主要是由于 Instance可被多次实例化，因此，在类加载时就直接实例化 Instance就可以保证线程安全问题。它基于 累加载机制避免了多线程的同步问题，不过这时候初始化 instance显然没有达到懒加载(lazy loading)的效果。
• 优点：未使用同步锁，执行效率会有所提高，线程安全。
• 缺点：直接在类加载时自动实例化对象，失去了懒加载机制下节约资源的优势，消耗内存。

public class Singleton {
    private static Singleton instance = new Singleton();  //类加载时就进行实例化
    private Singleton (){}
    public static Singleton getInstance() {
    return instance;
    }
}

注：懒汉式与饿汉式最主要的区别在于创建单例的时机不同，懒汉式根据是否需要实例，手动创建；饿汉式在类加载时自动创建单例

4. 双重校验锁方式(线程安全)

• 描述：双重校验锁(double-checked locking，DCL)也叫双检锁，JDK1.5出现的功能。这种方式采用双锁机制，同时加锁操作只需要对实例化那部分代码进行，只有当 Instance没有被实例化时(Instance == null) ，才需要进行加锁。
• 优点：懒加载，多线程环境下可保证线程安全，性能较高。
• 缺点：相比前几种方式，实现较为复杂。

• *双重校验锁的完善过程：

• 由于使用懒汉式同步方法会消耗过多性能，我们只在构建实例对象的时候进行同步。在调用 getInstance()时，访问的线程不需要竞争锁，都可以直接进入。再进行下一步判断，若此时实例对象还没有被构建，线程开始竞争锁，抢到锁的线程开始创建单例。

public class Singleton {
    private static Singleton Instance;
    private Singleton() {}

    public static Singleton getInstance() {
        if (Instance == null) {
            synchronized (Singleton.class) {  //在需要构建单例的时候给Class对象加锁
               Instance = new Singleton();
            }
        }
        return Instance;
    }
}

问题：在多个线程执行判断条件时，虽然只有一个线程能够抢到锁取创建单例，但是可能有其他线程已经进入了 if代码块，之后会再进行 if判断了，而这些线程等待释放锁后，随即又会创建实例对象，最终实例会被多次被创建。显然线程不安全。

1. 再增加一条判断条件，这也是双重校验锁中”双重”的由来。我们假设线程A抢到同步锁，然后创建实例，创建完毕释放锁。这时，线程B抢到锁，进行判断实例是否被创建，发现实例 instance已经被线程A初始化了，不可能等于null，直接退出，返回A线程创建的单例。

public class Singleton {
    private static Singleton Instance;
    private Singleton() {}

    public static Singleton getInstance() {
        if (Instance == null) {
            synchronized (Singleton.class) {  //在需要构建单例的时候给Class对象加锁
            if (Instance == null) {          //增加了判空条件
                  Instance = new Singleton();
                }
            }
        }
        return Instance;
    }
}

1. 在执行 Instance = new Singleton();时，大致可以分为三步：1）给 Instance实例分配内存；2）初始化 Instance的构造器；3）将 instance对象指向分配的内存地址（这一步 Instance就非null了）。由于JVM为了优化指令，提高程序的运行效率， 允许指令重排，导致在程序实际运行的时候，顺序变为1）>> 3）>> 2），这在单线程的情况下是没有问题的。但是，在 多线程的环境下，线程有可能拿到一个尚未被初始化的实例，程序必然报错。 使用 volatile 关键字可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

public class Singleton {
    private volatile static Singleton Instance;  //增加volatile关键字，防止JVM指令重排
    private Singleton (){}

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

5.静态内部类方式

• 描述：这种方式能达与双检锁功能相似，且实现更简单。由于 静态内部类的加载是在程序中调用静态内部类的时候加载的，和外部类的加载没有必然关系，因此当 Singleton 类加载时， 静态内部类 SingletonHolder 并没有被加载进内存。只有当调用 getInstance() 方法从而触发 SingletonHolder.INSTANCE 时 ， SingletonHolder 才会被加载，此时初始化 INSTANCE实例。实现了 延迟加载。 这种方式只适用于 静态域的情况，双检锁方式可在 实例域需要延迟初始化时使用。
• 优点：延时加载，按需加载，节约资源；由于JVM提供了对线程安全的支持，只会加载一遍，线程安全得到保证。
• 缺点：这种方式只适用于 静态域的情况。

public class Singleton {
    private Singleton() {
    }
    //静态内部类
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;    //访问静态内部类中静态成员
    }
}

6.枚举方式

• 描述：这是实现单例模式的 最佳方法。这种方式是《Effective Java》作者 Joshua Bloch 提倡的方式， 它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。出现反射攻击时，通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象。如果要防止这种攻击，需要在构造函数中添加防止实例化第二个对象的代码。解决序列化和反射攻击很麻烦，而枚举实现不会出现这两种问题，因此说枚举实现单例模式式最佳实践方法。
• 优点：单例模式的最佳实践，它实现简单，并且在面对复杂的序列化或者反射攻击的时候，不能调用 private方法，能够防止多次实例化，是目前最安全的实现单例的方法。
• 缺点：这种方式尚未被广泛采用，实际工作中，很少会被采用。

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {  //任意方法
    }
}

结语

一般情况下，不建议使用两种懒汉式实现单例模式；明确使用静态方法和实现懒加载效果时，会采用静态内部类方式；涉及到反序列化创建对象的时候，可以使用枚举方式；一般而言，饿汉式以及双重校验锁比较常用。

Original: https://www.cnblogs.com/KobeForever/p/WhereAmazingHappens1.html
Author: Joe__Bryant
Title: 设计模式——单例模式