单例模式(饿汉模式和懒汉模式)

1. 什么是单例模式

单例模式是 java 中最常见的设计模式之一. 这种模式涉及到了一个单一的类, 该类负责创建自己的对象，同时确保只有单个对象被创建.
换句话说, 就是:某些类的对象, 在整个应用的生命过程, 需要且仅需要一份

2. 单例模式的特点

单利模式的特点如下:

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

3. 单例模式的两种思想实现

单例模式中, 最常见的就是: 饿汉单例模式 和 懒汉单例模式, 接下来, 将对这两种模式进行进一步的详述.

3.1. 饿汉模式单例(天生线程安全)

饿汉模式: 一开始类加载的时候就实例化好对象, 以后需要的时候只管使用即可.

/**
 * 饿汉单例模式:
 * 1. 保存仅有的一个引用至一个静态变量中
 * 2. 一开始就对这个变量进行初始化(可以使用静态代码块 / 直接初始化)
 * 3. 提供一个方法可以返回这个对象
 * 4. 避免无意中犯错, 应该将这个类的构造方法标记成 private 的
 */
public class SingletonStarve {
    // 使用 final 修饰, 保证了原子性
   private static final SingletonStarve instance;
   
   // 变量只有在 SingletonStarve 被加载时才会执行, 而 SingletonStarve 这个类只会被加载一次
   static {
       instance = new SingletonStarve();
   }
   // 需要提供一个方法返回这个对象, 凡是要使用 instance 这个对象, 只能调用这个方法
   public static SingletonStarve getInstance() {
       return instance;
   }
   
   // 尽可能避免有人无意中构造出这个对象, 将这个类的构造方法标记成  private 的
   private SingletonStarve() {
   }
}

饿汉模式的缺点:
饿汉模式实例化好的对象是会占用一部分空间的, 如果一直不调用, 就可能会造成空间的浪费.

3.2. 懒汉模式单利(天生是线程不安全的)

懒汉模式: 延迟初始化, 即: 按需加载, 使用的时候再初始化对象.
懒汉模式一般情况下是线程不安全的.
在这里需要说明两种典型的线程不安全的情况:

1. read and write(读写): a = b; v++
2. check and modify(判断修改): if(…) {…}
   (在多线程的环境下, 真正执行时, 条件可能已经发生改变)

3.2.1. 线程不安全的懒汉模式

**
 * 懒汉单例模式:
 * 1. 保存仅有的一个对象至静态属性中
 * 2. 提供一个方法, 当需要使用时再进行初始化并返回
 * 3. 为了避免无意中构造对象, 将这个类的构造方法标记成 private 的
 */
public class SingletonLazy {
    // 保存对象至静态属性中
    private static SingletonLazy instance = null;

    // 提供初始化并返回这个对象的方法
    public static SingletonLazy getInstance() {
        // getInstance 这个方法被调用了, 说明有人需要该类的对象了
        if(instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }

    // 将这个对象的构造方法标记成 private 的
    private SingletonLazy() {
    }
}

为什么这种情况下线程是不安全的?
凡是需要使用 instance 这个对象时, 都只能调用 getInstance() 这个方法.
线程 A 在调用该方法时判断 Instance == null 的, 那么他认为这时 instance 对象还没有被实例化. 这时, 线程 B 抢占了 CPU, 同时在调用该方法时判断 Instance == null, 并实例化 instance 对象. 当 CPU 再次轮到 线程 A 时, 由于内存可见性问题, 线程 A 仍旧以为 instance 为 null, 进而再次实例化 instance 对象, 违背了单例模式的特点. 所以是线程不安全的.

3.2.2. 线程安全的懒汉模式

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

这种懒汉模式下, 使用了 synchronized + 二次判断 + volatile 修饰:

1. 将引用保存至静态变量时, 可能会出现代码重排序的情况, 因此可能会出现问题, 所以需要使用 volatile 关键字进行修饰.
2. 当对象还未被实例化时(instance == null), 才使用synchronized 对当前类进行加锁.
3. 进行了二次判断(instance == null). 防止多次实例化对象.

懒汉模式的优点:
由于是按需加载, 所以减少了空间的浪费.