单例模式：饿汉式与懒汉式

1 什么是单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1. 单例类只能有一个实例。
2. 单例类必须自己创建自己的唯一实例。
3. 单例类必须给所有其他对象提供这一实例。

2 单例模式介绍

意图：保证一个类仅有一个实例，并提供一个它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

3 实现方式

单例模式有多种实现方式，根据不同需求，选择不同的方式。

3.1 饿汉式

• 描述：这种方式比较常用，但容易产生垃圾对象。
• 优点：线程安全，没有加锁，执行效率会提高。
• 缺点：类加载时就初始化，浪费内存。

它基于 classloader 机制，避免了多线程的同步问题。

代码

/**
 * 饿汉式
 */
public class SingletonHungry {
    private static SingletonHungry instance = new SingletonHungry();

    private SingletonHungry(){
    }

    public static SingletonHungry getInstance(){
        return  instance;
    }

}

3.2 懒汉式

懒汉模式也分线程安全与线程不安全

• 描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。
  因为没有加锁synchronized，所以严格意义上它并不算单例模式。
• 缺点：线程不安全。

代码

/**
 * 懒汉式：线程不安全
 */
public class SingletonLazyUnsafe {
    private static SingletonLazyUnsafe instance;

    private SingletonLazyUnsafe (){
    }

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

在多线程的情况下，这样写可能会导致 instance 有多个实例。比如下面这种情况，考虑有两个线程同时调用getInstance()：

Time	Thread A	Thread B
T1	检查到 instance 为空
T2		检查到 instance 为空
T3		初始化对象A
T4		返回对象A
T5	初始化对象B
T6	返回对象B

3.3 synchronized 加锁

• 描述：线程安全，但是，效率很低，99% 情况下不需要同步。
• 优点：第一次调用才初始化，避免内存浪费。
• 缺点：必须加锁synchronized 才能保证单例，但加锁会影响效率。
  getInstance()的性能对应用程序不是很关键（该方法使用不太频繁）。

代码

/**
 * 懒汉式：线程安全
 */
public class SingletonLazySafe {
    private static SingletonLazySafe instance;
    private SingletonLazySafe(){
    }
    public static synchronized SingletonLazySafe getInstance() {
        if (instance == null) {
            instance = new SingletonLazySafe();
        }
        return instance;
    }
}

3.4 双重检查锁 (Double Checked Locking)

上面加锁虽然解决了问题，但是因为用到了synchronized，会导致很大的性能开销，并且加锁其实只需要在第一次初始化的时候用到，之后的调用都没必要再进行加锁。

• 描述：双重检查锁是对上述问题的一种优化。先判断对象是否已经被初始化，再决定要不要加锁。
• 优点：线程安全，可延迟加载

一般我们很容易写出下面代码

/**
 * 双重检查锁 double checked locking
 * 线程安全
 * 这种写法有隐患
 */
public class SingletonDCLWrong {
    private static SingletonDCLWrong instance;

    private SingletonDCLWrong(){
    }

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

执行双重检查是因为，如果多个线程同时通过了第一次检查，并且其中一个线程首先通过了第二次检查且实例化了对象，那么其他线程就不会再实例化对象。

这样除了初始化的时候出现加锁情况，后续的所有调用都会避免加锁而直接返回，解决了性能消耗问题。

隐患:

上述写法看似解决了问题，但是有一个很大隐患。实例化的那行代码（标记为error），实际上可以分解成一下三步骤：

1. 分配内存空间
2. 初始化对象
3. 将对象指向刚分配的内存空间

但是有些编译器为了性能，可能会将步骤2与步骤3进行重排序，顺序就变成了：

1. 分配内存空间
2. 将对象指向刚分配的内存空间
3. 初始化对象

现在考虑重排序后，两个线程发生了一下调用：

Time	Thread A	Thread B
T1	检查到 instance 为空
T2	获取锁
T3	再次检查到 instance 为空
T4	为 instance 分配内存空间
T5	将 instance 指向内存空间
T6		检查到 instance 不为空
T7		访问 instance （此时对象还未完成初始化）
T8	初始化 instance

在这种情况下，T7时刻 线程B对 instance 的访问，访问的是一个初始化未完成的对象。

正确的双重检查锁，代码

/**
 * 双重检查锁 double checked locking
 * 线程安全
 */
public class SingletonDCLRight {
    private volatile static SingletonDCLRight instance; // 这个有一个 volatile 关键字

    private SingletonDCLRight(){
    }

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

为了解决上述问题，需要在 instance 前加入关键字volatile。使用了volatile关键字后，重排序被禁止，所有的写（write）操作都将发生在读（read）操作之前。

volatile主要包含两个功能。

• 保证可见性。使用 volatile 定义的变量，将会保证对所有线程的可见性。
• 禁止指令重排序优化。
  由于 volatile 禁止对象创建时指令之间重排序，所以其他线程不会访问到一个未初始化的对象，从而保证安全性。

ps：volatile禁止指令重排序在 JDK 5 之后才被修复

3.5 静态内部类

• 描述：这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
• 优点：线程安全，调用效率高，可以延时加载。

代码

/**
 * 静态内部类
 * 线程安全
 */
public class SingletonInner {
    private SingletonInner(){
    }

    private static class Inner {
        private static final SingletonInner INSTANCE = new SingletonInner();
    }

    public static final SingletonInner getInstance() {
        return Inner.INSTANCE;
    }
}

3.6 枚举

• 描述：这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。
• 优点：线程安全，调用效率高
• 缺点：不能延时加载。

ps: JDK1.5 之后才加入 enum 特性

代码

/**
 * 枚举式
 * 线程安全
 */
public enum SingletonEnum {
    // 每个枚举都是通过 Class 在内部实现的，且所有的枚举值都是 public static final 的。
    // 类似 public static final SingletonEnum INSTANCE = new EnumSingleton();
    INSTANCE;

    public String method() {
        return "this is SingletonEnum's method";
    }
}