[JavaEE]单例设计模式

桃扇骨 2024-03-30 06:26 19阅读 0赞

![a4ad10a4218a478fb474ef69add6aca7.gif][]

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

> ![c4304daa3a1846adadc000eea43efbf4.png][]专栏简介: JavaEE从入门到进阶
> 
> ![1254c5b119a44cf0ae350489fb7736ad.png][]题目来源: leetcode,牛客,剑指offer.
> 
> ![4366a93aaa3142b5a0f16c7a2200339b.png][]创作目标: 记录学习JavaEE学习历程
> 
> ![52a3437a932f4621b25533c330f7c6cb.png][]希望在提升自己的同时,帮助他人,,与大家一起共同进步,互相成长.
> 
> ![14aa2f0648ae44a299b8f9832af57d2c.png][]学历代表过去,能力代表现在,学习能力代表未来!

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

## 目录 ##

单例模式

1.饿汉模式--单线程版

2.懒汉模式--单线程版

3.懒汉模式--多线程版

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

## 单例模式 ##

单例模式是常见的**设计模式**之一.

什么是设计模式?

> 设计模式就好比象棋中的棋谱 , "红方当头炮 , 黑方马来跳" , 针对红方的走法 , 黑方可以使用一些固定套路来应对 . 软件开发中也是如此 , 针对一个固定的问题场景 , 业界大佬以及总结出一些固定的套路 , 按照这个固定套路可以少走不少弯路.

单例模式能保证每个类只有一个实例对象 , 而不会创建出多个实例.

> 这一点在很多场景都有应用 , 如JDBC编程中 , 要求DataSource类只能创建一个实例对象.

单例模式的具体实现方式主要分为两种 , "饿汉模式"和"懒汉模式".

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

### 1.饿汉模式--单线程版 ###

顾名思义 , 一个饿了很久的人 , 看到吃的就会很急切."饿汉模式"在类加载阶段 , 就把实例对象给创建出来 , 给人一种很急切的感觉.

**代码示例:**

这段代码最关键的就是 , 在类中创建实例对象时用static修饰 .

>  *  1.static 保证了这个实例的唯一性 , static操作让instance属于类属性 , 类属性属于类对象 , 类对象又是唯一的 , 因此这个实例对象也是唯一的.
>  *  2.static 保证对象在类加载阶段就创建好 , 否则由于构造方法被private修饰 , 在main方法中无法直接创建实例对象.

class Singleton{
        //此处 , 先把实例创建出来.
        private static Singleton instance = new Singleton();
        public static Singleton getInstance(){
            return instance;
        }
        private Singleton(){}
    }
    public class ThreadDemo4 {
        public static void main(String[] args) {
            Singleton s = Singleton.getInstance();
        }
    }

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

### 2.懒汉模式--单线程版 ###

顾名思义 , 一个很懒的人绝对不会提前做一件事 , 只有等到非做不可的时候才去做.同样在代码中 , 这个实例并非是类加载的时候创建 , 而是第一次使用的时候才去创建.

class SingletonLazy{
        private static SingletonLazy instance = null;
        public static SingletonLazy getInstance(){
            if (instance == null){
                instance = new SingletonLazy();
            }
            return instance;
        }
        private SingletonLazy(){}
    }
    public class ThreadDemo4 {
        public static void main(String[] args) {
            SingletonLazy s1 = SingletonLazy.getInstance();
            SingletonLazy s2 = SingletonLazy.getInstance();
            System.out.println(s1 == s2);//true
        }
    }

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

### 3.懒汉模式--多线程版 ###

说到多线程 , 最先考虑的就是安全性 , 通过代码可以看出 , 饿汉模式多线程调用, 只涉及到读的操作 , 因此饿汉模式在多线程中是天然安全的.而懒汉模式多线程调用象 , 即需要读也需要写.

![97d3d9743aaf41edb11f7f767e060388.png][]

由于读和写操作不是原子性的 , 很容易出现出现多个线程同时load到null , 这时就会创建多个实例对象 , 很显然不符合单例模式.

![00152c879fef4746a6471987a5554395.png][]

**解决方式:**

出现上述线程安全问题 , 本质上是读 比较 和写操作不是原子的 , 因此需要加锁 , 才能保证这些操作是一个整体.

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

![b181ec3fc4274d5ea4db0791fde00c16.png][]

**改进方式:**

> 我们都知道加锁操作在程序中有很大的开销 , 因此为了提高代码执行效率 , 我们的加锁操作需要更加精确 , 分析上述代码可知 , 这里加锁操作在new对象之前是有必要的 , 但new对象之后 , 后续调用getnstance还有必要吗?后续instance的值一定是非空的 , 因此一定会触发return操作 , 相当于一个比较操作和一个返回操作 , 这两个操作都是读操作 , 此时不加锁也没事 , 因此我们对代码进行更进一步的修改.

此时不再是无脑加锁 , 只有满足条件才加锁.

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

此时多线程安全性还是没有做到万无一失 , 这段代码还存在指令重排序问题 , 之前我们把new操作看做是一个整体 , 这在单线程中没有任何问题 , 可一旦涉及到多线程问题就显而易见.new操作通常需要三步:

>  *  1.申请内存空间
>  *  2.调用构造方法 , 把内存空间初始化成一个合理的对象.
>  *  3.把内存对象地址赋值给instance引用.

正常情况下是按照1->2->3的顺序来执行 , 但有时编译器为了提高执行效率 , 会进行指令重排序的操作 , 此时执行顺序就可能是1->3->2 , 如果是单线程没有任何区别 , 但如果是多线程就有问题了 , 假设 t1 按照1->3->2的顺序执行 , 当 t1 执行到1->3之后就被CPU挂起 , 此时 t2 来执行 , 站在 t2 的视角此时的 instance 引用就非空了 , 那么 t2 就会返回 instance 引用 , 并且尝试使用引用中的属性 , 但由于 t1 中的->2还没执行完 , 所以 t2 拿到的就是非法对象.

所以我们需要使用 volatile 去修饰该对象 , 来防止指令重排序.

volatile有两个功能:

>  *  1.解决内存可见性问题.
>  *  2.禁止指令重排序.

**最终完全版:**

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

[a4ad10a4218a478fb474ef69add6aca7.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/8daa465c563c44ed954813c660339311.gif
[c4304daa3a1846adadc000eea43efbf4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4d33fb8a90df45599a4304b086af2915.png
[1254c5b119a44cf0ae350489fb7736ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ffe9bb9be13843d6a73bc13e9133cf83.png
[4366a93aaa3142b5a0f16c7a2200339b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2e376c1fb6ed454888f6fd8fa54c6c31.png
[52a3437a932f4621b25533c330f7c6cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/838e39fb381e4af48bdfb546141ea67f.png
[14aa2f0648ae44a299b8f9832af57d2c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/be8085be2d7c4f92987ac87766ccd26c.png
[97d3d9743aaf41edb11f7f767e060388.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/27f7573151374ca6aece477b3ee96c88.png
[00152c879fef4746a6471987a5554395.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7ae7b9c6762f4ba79b99426dd3812109.png
[b181ec3fc4274d5ea4db0791fde00c16.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/5700af9c32154db8944332b820040944.png