设计模式--单例模式说明

蔚落 2024-02-18 12:54 35阅读 0赞

#### 文章目录 ####

*  前言
 *  一、单例模式
 *   *  1.饿汉模式
     *   *  1.代码示例
         *  2.解释说明
     *  2.懒汉模式
     *   *  1.解释说明
         *  2.解释说明
 *  二、单例模式中线程安全问题
 *  总结

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

## 前言 ##

设计模式是在软件设计中常见的一种解决问题的方法论，它是经过反复验证和实践的一种通用的解决方案，用来解决在软件设计中常见的问题。

**设计模式就是套路**，就好像你学习六级的时候，针对阅读问题有阅读的套路，针对听力问题有听力的套路，你根据那些套路，可以更好的做题。在软件开发中也有很多常见的"问题场景"，针对这些问题场景，大佬们总结了一些套路，按照套路来实现代码，会更顺利，减少出错的可能性。

今天我们来说一下单例模式。

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

## 一、单例模式 ##

单例模式的意思就是能保证某个类在程序中只存在唯一一份实例，而不会创建多个实例，比如在JDBC的DataSource实例只有一个。**单例模式具体的实现方式, 分成 “饿汉” 和 “懒汉” 两种**。

### 1.饿汉模式 ###

#### 1.代码示例 ####

class Singleton {
        
        //创建实例
        private static Singleton instance = new Singleton();
    
        //如果需要使用这个实例，统一通过Singleton.getInstance()获取
        public static Singleton getInstance() {
        
            return instance;
        }
    
        //将构造方法设置为private,防止外界使用new方法进行实例化
        private Singleton() {
        
        }
    }
    
    public class test4 {
        
        public static void main(String[] args) {
        
            Singleton s1 = Singleton.getInstance();
            Singleton s2 = Singleton.getInstance();
            //Singleton s3 = new Singleton();
            System.out.println(s1 == s2);
        }
    }

> 运行结果

![在这里插入图片描述][bce6d142b172482a930854886e102b08.png]

#### 2.解释说明 ####

> 1.**为什么叫饿汉模式**: 在类加载阶段，就把实例创建出来，给人一种比较急切的感觉

补充:Java程序的执行可以分为以下几个阶段:  
1.源代码阶段  
2.编译阶段: 主要是将Java文件编译成.class文件，生成字节码  
3.类加载阶段: Java进程能够找到并读取对应的Java文件，就会读取文件内容，并解析，构造成类对象…这一系列操作过程称为类加载阶段  
4.运行阶段

> 2.保证实例唯一: 1.static保证实例唯一；2.构造方法是设为private，外面的代码中无法new

### 2.懒汉模式 ###

#### 1.解释说明 ####

class SingletonLazy {
        
        //创建实例
        private static SingletonLazy instance = new SingletonLazy();
    
        //如果需要使用这个实例，统一通过SingletonLazy.getInstance()获取
        public static SingletonLazy getInstance() {
        
            if (instance == null) {
        
                instance = new SingletonLazy();
            }
            return instance;
        }
    
        //将构造方法设置为private,防止外界使用new方法进行实例化
        private SingletonLazy() {
        
        }
    }
    
    public class test5 {
        
        public static void main(String[] args) {
        
            SingletonLazy s1 = SingletonLazy.getInstance();
            SingletonLazy s2 = SingletonLazy.getInstance();
            //Singleton s3 = new Singleton();
            System.out.println(s1 == s2);
        }
    }

> 运行结果

![在这里插入图片描述][d94227ee1c394930a1ea135b0199c2df.png]

#### 2.解释说明 ####

> 在这个代码中，这个实例并非在类加载的时候创建，而是真正第一次使用的时候去创建，相比上一个在类加载阶段就把实例创建出来，就比较懒了，所以叫懒汉模式

## 二、单例模式中线程安全问题 ##

在上面的饿汉模式和懒汉模式中，如果在多线程环境下调用getInstance()，是否线程安全?

> 在下面中我们可以看到饿汉模式只有读操作，线程是安全的，而懒汉模式既有读操作又有写操作，线程是不安全的

![在这里插入图片描述][737249c5fdff45589f91468e9fd0fc1c.png]

> 在懒汉模式代码下，下面有t1和t2两个线程分别读取instance的值是否为空，若为空则进行new操作，在下图中我们**可以看出读和写这两个操作不是原子的，导致t2读到的值可能是t1还没有来得及修改的值，从而造成了脏读**，导致分别进行了两次new操作，不符合单例模式只允许存在一个实例，而不会创建多个实例的情况，从而存在线程安全问题

![在这里插入图片描述][c6228bd0591c4affb3bfac2b3da9f6f8.png]

> 如何解决上面的问题，是懒汉模式能成为线程安全，方法是**加锁**

![在这里插入图片描述][6cdd0e291687479da3855073259e73eb.png]

> 这个锁要加在外面，从而保证读写是原子性的

class SingletonLazy {
        
        //创建实例
        private static SingletonLazy instance = new SingletonLazy();
    
        //如果需要使用这个实例，统一通过SingletonLazy.getInstance()获取
        public static SingletonLazy getInstance() {
        
            synchronized (SingletonLazy.class) {
        
                if (instance == null) {
        
                    instance = new SingletonLazy();
                }
            }
            return instance;
        }
    
        //将构造方法设置为private,防止外界使用new方法进行实例化
        private SingletonLazy() {
        
        }
    }

> 思考: 如果锁加在里面，那么这个加锁操作会有效吗?显然是不有效的，因为并没有将instance的读取操作进行加锁，此时的读和写操作仍为非原子的

![在这里插入图片描述][326854478b304ecab43565bd82a06ce6.png]

但是上面的代码即使进行了加锁还是会有问题的，加锁操作会有时间开销的，如果每一次调用这个getInstance都需要加锁，那时间开销就会很大，这个代码是否真的每一次都需要加锁呢?

显然不是的，上面代码中的加锁只是针对new出对象以前要进行加锁，一旦对象已经new出来了，单例模式明确限制只能有一个实例，所以**当new出对象后，此时的instance一直都是非空的**，直接触发return，相当于这时候的**代码只有一个比较非空和返回操作，均为读操作，此时不加锁也是没有关系的**。

> 优化

class SingletonLazy {
        
        //创建实例
        private static SingletonLazy instance = new SingletonLazy();
    
        //如果需要使用这个实例，统一通过SingletonLazy.getInstance()获取
        public static SingletonLazy getInstance() {
        
            if (instance == null) {
        
                synchronized (SingletonLazy.class) {
        
                    if (instance == null) {
        
                        instance = new SingletonLazy();
                    }
                }
            }
            return instance;
        }
    
        //将构造方法设置为private,防止外界使用new方法进行实例化
        private SingletonLazy() {
        
        }
    }

> 上面有两次if (instance == null)的判断，但是这两次判断的目的是完全不相同的，**第一个if (instance == null)负责判定是否需要添加锁，第二个if (instance == null)负责的是是否需要创建对象**

> 但是上面的代码进行优化后，还会有问题

**1.内存可见性问题**

假设有很多个线程，都去进行getInstance()，这个时候就可能存在内存可见性问题，这是因为在多线程环境下，一个线程对instance的修改，可能并不会被其他线程给立即感知，导致其他线程拿到的instance并不是最新的

**2.指令重排序问题**

在执行instance = new SingletonLazy();这行代码时，实际上会分为三步操作：1.分配内存、2.初始化对象、3.设置instance指向刚分配的内存地址。由于这三步操作不是原子性的，所以在多线程环境下，就可能出现指令重排序的问题。

可以形象的理解为你在食堂打饭的情形，分为三个步骤：1.阿姨拿出饭盘 2.阿姨给你打饭 3.阿姨把饭给你，在指令重排序中可能变为132，那么就变成:1.阿姨拿出饭盘 3.阿姨把饭给你 2.阿姨给你打饭，这时候你虽然拿到了饭盘，但是你的盘中还没有饭，从而出现问题。

> 解决方案:添加volatile，volatile既可以解决内存可见性问题，也可以解决指令重排序问题

class SingletonLazy {
        
        //创建实例
        private static volatile SingletonLazy instance = new SingletonLazy();
    
        //如果需要使用这个实例，统一通过SingletonLazy.getInstance()获取
        public static SingletonLazy getInstance() {
        
            if (instance == null) {
        
                synchronized (SingletonLazy.class) {
        
                    if (instance == null) {
        
                        instance = new SingletonLazy();
                    }
                }
            }
            return instance;
        }
    
        //将构造方法设置为private,防止外界使用new方法进行实例化
        private SingletonLazy() {
        
        }
    }

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

## 总结 ##

单例模式是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点。在多线程环境下，为了避免多个线程同时创建实例导致的问题，可以使用双重检查锁定模式来确保单例对象的原子性创建。

[bce6d142b172482a930854886e102b08.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/95c5b3b1132b4fad93b49e7d147c7fc5.png
[d94227ee1c394930a1ea135b0199c2df.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/f0807c4fc79a43998aa5f5f89e7d3a26.png
[737249c5fdff45589f91468e9fd0fc1c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/a9ceb7d441f74bc89c46663c78be1c55.png
[c6228bd0591c4affb3bfac2b3da9f6f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/f5c2108098e8428088a565e7563f909e.png
[6cdd0e291687479da3855073259e73eb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/6d787dec94a7437ab30ff1d230b7591e.png
[326854478b304ecab43565bd82a06ce6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/bd7bb857f7f0421a85730a5560ddf558.png