单例模式实现

我就是我 2024-04-23 21:19 2阅读 0赞

> ⭐ 作者：小胡\_不糊涂  
> 🌱 作者主页：[小胡\_不糊涂的个人主页][Link 1]  
> 📀 收录专栏：[JavaEE][]  
> 💖 持续更文，关注博主少走弯路，谢谢大家支持 💖

#### 单例模式 ####

*  1. 什么是单例模式
 *  2. 饿汉模式
 *  3. 懒汉模式

## 1. 什么是单例模式 ##

单例模式能保证某个类在程序中只存在唯⼀⼀份实例，⽽不会创建出多个实例。  
单例模式最常⻅的实现方式是“饿汉”和“懒汉”两种。

*  饿汉模式是在类加载的同时，创建实例。
 *  懒汉模式在类加载时不创建实例，只有第一次使用的时候才会创建实例。

就好比十只羊吃草，饿汉模式就是直接让十只羊全部开吃，而懒汉模式就是一个吃完下一个再吃。

## 2. 饿汉模式 ##

class Singleton{
        
        private static Singleton instance=new Singleton();
        public static Singleton getInstance(){
        
            return instance;
        }
        private Singleton(){
        }
    }
    public class TestDemo6 {
        
        public static void main(String[] args) {
        
            Singleton s=Singleton.getInstance();
            Singleton s1=Singleton.getInstance();
            System.out.println(s==s1);//true
        }
    }

该模式下的getInstance直接返回instance实例，该操作是一个“读操作”，对于多个线程读取同一个变量时，此模式下的操作是线程安全的。

## 3. 懒汉模式 ##

class SingleLazy{
        
        private static SingleLazy instance=null;//不立即创建实例
        public static SingleLazy getInstance(){
        
            if(instance==null){
        
                instance=new SingleLazy();
            }
            return instance;
        }
        private SingleLazy(){
        }
    }

该模式的实现是**线程不安全**的。  
线程安全问题发⽣在⾸次创建实例时。如果在多个线程中同时调⽤ getInstance ⽅法，就可能导致创建出多个实例，就比如下面这种情况：  
![在这里插入图片描述][9ffd003c6dfb4e44a9dfb600918e00a3.png]  
想要改善该问题，可以加上**synchronized**：

class SingleLazy1{
        
        private static Object loker=new Object();
        private static SingleLazy1 instance=null;//volatile：解决重排序问题
        public static SingleLazy1 getInstance() {
        
                synchronized (loker) {
        
                    if (instance == null) {
        
                        instance = new SingleLazy1();
                    }
                }
            
            return instance;
        }
        private SingleLazy1(){
        }
    }

![在这里插入图片描述][6922c72aef254e56929c9c435106bc14.png]  
此时，该代码已经没有线程安全问题了。

当instance已经创建过了，后面再调用getInstance就应该是直接返回instance实例，但是每次调用时仍会先加锁进入if中再解锁，就会很麻烦，降低了运行效率。而且加锁也就意味着可能会有阻塞，一旦线程进入阻塞状态，就不知道何时才能解除了。

所以在上述代码中可以加以改进，直接**在加锁之前先进行一次判空**：

class SingleLazy1{
        
        private static Object loker=new Object();
        private static volatile SingleLazy1 instance=null;//volatile解决指令重排序问题
        public static SingleLazy1 getInstance() {
        
            if(instance==null) {
        
                synchronized (loker) {
        
                    if (instance == null) {
        
                        instance = new SingleLazy1();
                    }
                }
            }
            return instance;
        }
        private SingleLazy1(){
        }
    }

![在这里插入图片描述][6407155ff82847fc89ec606775a48587.png]  
如果按照132顺序就会产生下面的错误，所以为了避免该错误的发生，就使用volatile来禁止指令的重排序。  
![在这里插入图片描述][0ff5d6a31d6e4d6db9f261f9d9cb1e81.png]

[Link 1]: https://blog.csdn.net/iLoyo_
[JavaEE]: http://t.csdnimg.cn/p0IQF
[9ffd003c6dfb4e44a9dfb600918e00a3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/d507cbb11431440da8a30f708c512465.png
[6922c72aef254e56929c9c435106bc14.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/b7dcbc55e6754d1d8599f6fcd361b1b6.png
[6407155ff82847fc89ec606775a48587.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/a1a89d1888084e0b87f6cb03510e2e98.png
[0ff5d6a31d6e4d6db9f261f9d9cb1e81.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/81dd0da77a6a4372b66104e616d415f9.png