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

目录

一、什么是单例模式

二、饿汉模式

三、懒汉模式

---

一、什么是单例模式

单例模式是Java中的设计模式之一，能够保证某个类在程序中只存在唯一一份实例，而不会创建出多个实例

单例模式有很多实现方式，最常见的是饿汉和懒汉两种模式

二、饿汉模式

饿汉模式在类加载时就创建实例

如何实现饿汉式单例模式？

1. 在类中完成实例的初始化，在创建的类中创建唯一实例

2. 对外提供获取该唯一实例的方法，提供访问该实例的全局静态方法getInstance()，来获取该类的唯一实例

3. 构造方法私有化，保证类外部不能实例化，只有在类中创建的唯一实例

//饿汉式单例模式
public class HungrySingLeton {
    //在类中创建唯一实例
    private static final HungrySingLeton instance = new HungrySingLeton();
    
    //构造方法私有化，保证类外部不能进行实例化
    private HungrySingLeton(){}

    //对外提供获取该唯一实例的方法
    public static HungrySingLeton getInstance(){
        return instance;
    }
}

饿汉式单例模式线程安全吗？

饿汉式单例模式在类加载时就进行初始化，创建唯一实例。它在线程还没出现之前就实例化了，外部只能通过getInstance()方法来获取唯一实例，相当于“读操作”，因此是线程安全的

饿汉式单例模式的缺点

在类加载时就创建实例，并一直在内存中，若不使用该实例，该实例仍然存在，此时存在内存浪费问题

三、懒汉模式

类加载时不创建实例，直到第一次使用的时候才创建实例

如何实现懒汉模式？

懒汉模式的实现与饿汉模式类似，唯一的区别是懒汉模式直到第一次使用的时候才会创建实例

1. 在类中创建唯一实例，并将该实例的初始值设为null

2. 对外提供获取该唯一实例的方法，若是第一次使用该方法，则创建实例

3.  构造方法私有化，保证类外部不能实例化，只有在类中创建的唯一实例

public class LazySingleton {
    //在类中创建唯一实例,并将其置为null
    private static LazySingleton instance = null;
    
    //构造方法私有化，保证类外部不能进行实例化
    private LazySingleton(){}
    
    //对外提供获取该唯一实例的方法
    public static LazySingleton getInstance(){
        //若是第一次使用该方法，则初始化instance
        if (instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
    
}

懒汉模式线程安全吗？

 在多线程情况下，可能会出现创建多个实例的情况

如何解决线程安全问题？

通过加锁，来解决线程安全问题

将判断instance是否为空，和创建实例两个操作加上锁，或是直接在方法上加上synchronized，从而保证在上图的情况下，也只创建一个实例

public static LazySingleton getInstance(){
        synchronized (LazySingleton.class){
            //若是第一次使用该方法，则初始化instance
            if (instance == null){
                instance = new LazySingleton();
            }
        }
        return instance;
    }

 或

public synchronized static LazySingleton getInstance(){
        //若是第一次使用该方法，则初始化instance
        if (instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }

 此时

由于加锁和解锁开销较高，而懒汉式单例模式仅在第一次调用时，才会存在可能创建多个实例的问题，在后面调用getInstance()方法时，判断instance不为空，直接返回instance，而在加锁后，无论是否已经存在实例，在多线程情况下都会发生阻塞，此时存在执行效率低的问题

因此，在加锁前，判断是否已经创建实例，若已经创建实例，则直接返回instance，若未创建实例，则进行加锁操作

 public static LazySingleton getInstance(){
        //判断是否已经创建实例，若已经创建实例，则不加锁，直接返回instance
        if(instance == null){
            //若实例未创建，则向下执行来竞争锁
            //竞争成功的锁，进行创建实例操作
            synchronized (LazySingleton.class){
                //在竞争成功的锁创建实例并释放锁后
                //其他竞争到锁的线程被内层if挡住，不会创建多个实例
                if (instance == null){
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }

通过两个if条件判断，降低了锁竞争的频率，既保证了线程安全，又提高了执行效率

此时线程安全了吗？

此时，指令重排序，也可能引起线程安全问题

指令重排序，是编译器优化的一种方式，通过调整原有代码的执行顺序，在保证逻辑不变的前提下，提高程序的效率

在创建实例时，可将其分为三个步骤

1. 申请一段内存空间

2. 在该内存空间上调用构造方法，创建出实例

3. 将该内存地址赋值给instance引用变量

正常情况下，创建实例是按照1 2 3的顺序来执行的，而编译器也可能会将其优化为1 3 2的顺序来执行

而当按照1 3 2 的方式来创建实例时，就可能会出现问题

如何解决指令重排序带来的线程安全问题？

使用volatile 

volatile能够禁止指令重排序，从而保证创建实例时，按照1 2 3的顺序来创建出实例，保证创建出初始化的实例

public class LazySingleton {
    //在类中创建唯一实例,并将其置为null
    //volatile:禁止指令重排序
    private volatile static LazySingleton instance = null;

    //构造方法私有化，保证类外部不能进行实例化
    private LazySingleton() {
    }

    //对外提供获取该唯一实例的方法
    public static LazySingleton getInstance() {
        //判断是否已经创建实例，若已经创建实例，则不加锁，直接返回instance
        if (instance == null) {
            //若实例未创建，则向下执行来竞争锁
            //竞争成功的锁，进行创建实例操作
            synchronized (LazySingleton.class) {
                //在竞争成功的锁创建实例并释放锁后
                //其他竞争到锁的线程被内层if挡住，不会创建多个实例
                if (instance == null) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

懒汉模式在类加载时，并没有进行实例化，而是在第一次调用getInstance()方法的时候，才进行实例化。若一直没有调用getInstance()方法，则不创建该唯一实例，此时节省了实例化的开销