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

心已赠人 2024-02-05 15:18 15阅读 0赞

**目录**

一、什么是单例模式

二、饿汉模式

三、懒汉模式

--------------------

## 一、什么是单例模式 ##

单例模式是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;
        }
        
    }

> **懒汉模式线程安全吗？**

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

![d5c3214aa26a4773899626b514dcf1a0.png][]

> **如何解决线程安全问题？**

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

将**判断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;
        }

此时

![813d3474491042c09e9c6ada32f70cfa.png][]

由于加锁和解锁开销较高，而懒汉式单例模式仅在第一次调用时，才会存在可能创建多个实例的问题，在后面调用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 的方式来创建实例时，就可能会出现问题

![3e63e54c4f66419ebfee8c249d5bebc3.png][]

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

使用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()方法，则不创建该唯一实例，此时节省了实例化的开销

[d5c3214aa26a4773899626b514dcf1a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/2c17a01aefd14b5bb86628eab6f0e528.png
[813d3474491042c09e9c6ada32f70cfa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/e2e700f2452844dfa5dd39b76e4a5abd.png
[3e63e54c4f66419ebfee8c249d5bebc3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/f4dcea68fd03496a9731e65e2a95f485.png