【Java|多线程与高并发】设计模式-单例模式(饿汉式,懒汉式和静态内部类)

一时失言乱红尘 2023-10-12 19:53 5阅读 0赞

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

*  1. 前言
 *  2. 单例模式
 *  3. 如何保证一个类只有一个实例
 *  4. 饿汉式单例模式
 *  5. 懒汉式单例模式
 *  6. 实现线程安全的懒汉式单例
 *  7. 静态内部类实现单例模式
 *  8. 总结

## 1. 前言 ##

> 设计模式是一种在软件开发中常用的解决复杂问题的方法论。它提供了一套经过验证的解决方案，用于解决特定类型问题的设计和实现。设计模式可以帮助开发人员提高代码的可重用性、可维护性和可扩展性。

设计模式有很多,本文主要介绍单例模式.  
![在这里插入图片描述][08c287700ab546cab2b269f6a08961fe.gif_pic_center]

## 2. 单例模式 ##

单例模式是一种创建型设计模式，它保证**一个类只有一个实例**，并提供一个全局访问点来获取该实例。

## 3. 如何保证一个类只有一个实例 ##

在Java中,通常使用`static`关键字来保证 类只有唯一的实例.

在单例模式中，`类的构造函数被私有化`，以防止外部代码直接创建实例。然后，通过一个**静态方法或静态变量**来获取类的唯一实例。

如果实例不存在，则创建一个新的实例并返回；如果实例已存在，则直接返回该实例。

而是实现上述的方法有很多,下面介绍三种常见的实现模式:

1.  饿汉式
2.  懒汉式
3.  静态内部类

## 4. 饿汉式单例模式 ##

> 饿汉式单例: 在类加载时就创建实例，保证在任何情况下都有一个实例可用。

代码示例:

public class Singleton {
        
        private static final Singleton instance = new Singleton();
        
        private Singleton() {
        
    		// 私有化构造函数
        }
    
        public static Singleton getInstance() {
        
            return instance;
        }
    }

代码分析:  
![在这里插入图片描述][df8189cff6b048b0a8837859589fd47c.png_pic_center]

私有化构造函数使得外部无法直接创建实例，如果其它线程想到得到`Singleton`类的实例,只能通过`Singleton`类提供的`getInstance()`方法得到.

## 5. 懒汉式单例模式 ##

> 懒汉式单例: 延迟加载实例，只有在需要时才创建实例。

代码示例:

public class SingletonLazy {
        
        private static SingletonLazy instance = null;
        private SingletonLazy(){
        
    		// 私有化构造方法
        }
        public static SingletonLazy getInstance(){
        
            if (instance == null){
        
                instance = new SingletonLazy();
            }
            return instance;
        }
    }

代码分析:  
![在这里插入图片描述][82a4eca4944c46e6a3a8c7a1b5fc16e7.png_pic_center]

如果后续代码中没有调用`getInstance`方法,那么就把创建实例那一步给省下来了.

上述代码中,那种实现单例模式的方式是线程安全的?

> 答案是 饿汉模式
> 
> 饿汉模式并没有涉及到修改,而懒汉模式即涉及到读有涉及到修改.那么在多线程模式中就不安全了.

> 设想一个场景, 如果在懒汉模式下,两个线程同时去调用getInstance方法,如果一个线程读到的instance为null,并给instance进行实例的创建,而另外一个线程读到的instance还是为null,又给instance创建了一次实例.那么instance就被创建多次了

## 6. 实现线程安全的懒汉式单例 ##

既然懒汉模式在多线程的环境下不安全,那么如果保证懒汉模式在多线程的环境下安全呢?

既然涉及到多线程,就离不开"锁",也就是 `synchronized`

示例:  
![在这里插入图片描述][bd7a32c556e945fa8b328247d311e9d5.png_pic_center]  
通过加锁的方式,**解决了线程安全问题**,但是又*带来了新的问题.*

懒汉式单例只是第一次调用`getInstance`方法时才会发生线程不安全问题.一旦创建好了,线程就安全了.

但上述通过加锁的方式,会导致线程已经安全时仍然时需要加锁,`有些多此一举了`. 且加锁开销比较大,影响效率.

**那么如果保证线程安全时不加锁呢?**

> 实例没有创建前,线程不安全.实例创建之后,线程安全. 那么就可以在加锁操作前在进行一次判断.

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

代码分析:  
![在这里插入图片描述][7a0a29b05a804f7bb2d1cd75e94c0d4d.png_pic_center]

使用`双重if`保证只创建一次实例以及保证在线程安全时不进行加锁. 这里要重点进行理解.

但仔细思考上述**代码仍然有一个问题**.

假如两个线程同时调用`getInstance`方法,第一个线程拿到锁,进入第二层if,开始进行new对象.

这里的new操作可以分为:

1.  申请内存,得到内存首地址
2.  调用构造方法,来初始化实例
3.  把内存的首地址赋值给instance引用

上述的new操作,编译器可能会进行"指令重排序". 就可能会导致`无序写入`的问题

上述步骤中的2和3,在单线程环境下是可以调换顺序的,并不会影响结果.

但在多线程环境中就会导致`无序写入`问题:

1.  线程A执行到instance = new Singleton();这行代码时，由于指令重排序，可能会先执行分配内存空间、初始化实例对象、将instance指向内存空间这三个操作的任意组合，而不是按照代码顺序执行。
2.  假设线程A执行完了分配内存空间和初始化实例对象的操作，但还没有将instance指向内存空间，此时线程B执行到第一个instance == null的判断，结果为false，就会直接返回instance，但此时instance并没有正确初始化。

为了解决上述问题,就可以使用`volatile`关键字. 它可以禁止指令重排序优化，保证instance的写操作先于读操作，从而避免其他线程在没有正确初始化实例时获取到instance。

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

上述就是一个在多线程环境下完全安全的懒汉式单例模式的写法.

## 7. 静态内部类实现单例模式 ##

除了上述方式,使用静态内部类也能实现单例模式.

> 该方式利用静态内部类的特性来实现懒加载和线程安全。

代码示例:

public class Singleton {
        
        private Singleton() {
        
            // 私有化构造函数
        }
        
        private static class SingletonHolder {
        
            private static final Singleton instance = new Singleton();
        }
        
        public static Singleton getInstance() {
        
            return SingletonHolder.instance;
        }
    }

静态内部类SingletonHolder持有Singleton的唯一实例，当第一次调用getInstance方法时，才会触发SingletonHolder的初始化，从而创建实例。

由于静态内部类的初始化是线程安全的，因此可以确保在多线程环境下只有一个实例被创建。

## 8. 总结 ##

本文主要介绍了饿汉式,懒汉式和静态内部类三种实现单例模式的方式,其中 懒汉式单例 很重要,要着重理解双重if的含义.

需要注意的是，以上方式都可以在多线程环境下保证单例的正确创建，但在特殊情况下，**如使用反射或序列化/反序列化等机制，仍然可能破坏单例的唯一性。**

在实际应用中，需要根据具体场景和需求选择合适的单例模式实现方式。

![在这里插入图片描述][5cf20061bb5f4d108508ee06f60b0eaf.gif_pic_center]

> 感谢你的观看!希望这篇文章能帮到你!  
> 专栏: [《从零开始的Java学习之旅》][Java]在不断更新中,欢迎订阅!  
> “愿与君共勉,携手共进!”  
> ![在这里插入图片描述][8fbf2a7f2d0e4db782e58035677a303d.png_pic_center]

[08c287700ab546cab2b269f6a08961fe.gif_pic_center]: https://img-blog.csdnimg.cn/08c287700ab546cab2b269f6a08961fe.gif#pic_center
[df8189cff6b048b0a8837859589fd47c.png_pic_center]: https://img-blog.csdnimg.cn/df8189cff6b048b0a8837859589fd47c.png#pic_center
[82a4eca4944c46e6a3a8c7a1b5fc16e7.png_pic_center]: https://img-blog.csdnimg.cn/82a4eca4944c46e6a3a8c7a1b5fc16e7.png#pic_center
[bd7a32c556e945fa8b328247d311e9d5.png_pic_center]: https://img-blog.csdnimg.cn/bd7a32c556e945fa8b328247d311e9d5.png#pic_center
[7a0a29b05a804f7bb2d1cd75e94c0d4d.png_pic_center]: https://img-blog.csdnimg.cn/7a0a29b05a804f7bb2d1cd75e94c0d4d.png#pic_center
[5cf20061bb5f4d108508ee06f60b0eaf.gif_pic_center]: https://img-blog.csdnimg.cn/5cf20061bb5f4d108508ee06f60b0eaf.gif#pic_center
[Java]: https://blog.csdn.net/m0_63463510/category_11797418.html
[8fbf2a7f2d0e4db782e58035677a303d.png_pic_center]: https://img-blog.csdnimg.cn/8fbf2a7f2d0e4db782e58035677a303d.png#pic_center