单例模式的理解

单例模式

原子操作

原子操作：顾名思义就是不可分割的操作，该操作只存在未开始和已完成两种状态，不存在中间状态

单例模式分为：饿汉模式和懒汉模式。单例模式之所以被称为单例模式，是因为我们在创建单例模式类的时候，就把该类的构造方法使用private进行修饰，以便在该类外，不能直接创建出一个实例，所以在单例模式下一个类只能new一个对象。就像吃饭的碗一样，单例模式的目的就是尽量少买碗，以免占用资源。

饿汉模式

饿汉模式指的是在单例模式中，在对单例进行初始化的时候，直接赋予单例实例，直接new出一个对象。

饿汉模式可以这样理解：我们平时在自己家里的时候，都洗过碗。就比如说，晚饭要使用了4个碗，在吃晚饭前，我们就把4个碗给刷了。这里之所以被称为饿汉模式是因为，在饿汉模式中，创建实例的时候比较着急。在初始化的时候，就直接创建实例。

//创建出一个单例模式
    //单例模式分为饿汉模式和懒汉模式
class Singleton{
    //在饿汉模式中，在进行初始化的时候，直接创建出实例
    public static Singleton instance = new Singleton();
    //使用private 修饰该类的构造方法，在类外无法创建出一个该类的对象
    private Singleton(){}
    //在类外调用该类中的实例
    public static Singleton getInstance(){
        return instance;
    }
}    
public class TestDemo2 {
    public static void main(String[] args) {
        //Singleton singleton = new Singleton();
        Singleton single = Singleton.getInstance();
    }
}

由上面代码可以看得到，在饿汉模式下的单例模式，我们在初始化的时候就直接new出了对象。

懒汉模式

懒汉模式也可以这样理解：午饭我们使用了4个碗，吃完饭我们先不洗碗，等到吃晚饭的时候咱们确定晚饭要使用了2个碗，这时候再洗碗，剩下两个碗不管；吃完晚饭后等到第二天中午，确定了这餐饭要3个碗，这时候再拿三个碗出来洗。在生活中这两种洗碗方法似乎感觉不到很大的差距，但是在计算机中，懒汉模式要比饿汉模式要好一些。

那么为什么在计算机中懒汉模式要比饿汉模式要好一些呢?

就比如说，现在有一个1G的图片文件，如果按照饿汉模式，那么计算机就会在内存中一下把这1G大的图片文件全部加载出来，这不就耗费CUP资源，并且如果计算机用户在浏览图片文件的时候，就看了一点没有全部把图片文件浏览完。那么这样的饿汉模式不就是费力不讨好好吗？

class Singleton2{
    //懒汉模式，在该模式中不着急创建出实例，在类外需要的时候，我们再进行创建
    public static Singleton2 instance = null;
    private Singleton2(){}
    public static Singleton2 getInstance(){
        if(instance == null){
            instance = new Singleton2();
        }
        return instance;
    }
}    
public class TestDemo3 {
    public static void main(String[] args) {
        Singleton2 singleton2 = Singleton2.getInstance();
    }
}

这两种单例模式的线程安全问题

怎样会造成线程不安全

线程安不安全，具体是在多线程环境之下，并发调用的getInstance()方法是否会产生bug

造成线程不安全的案例有5种。（以后补充）

1. 线程抢占式执行，线程间的调度充满了随机性。
2. 多线程对一个变量进行修改。
3. 针对变量操作不是原子的
4. 内存可见性问题
5. 指令重排序问题。

饿汉模式的线程安全

在饿汉模式中的getInstance()方法，在该方法中只有一个return操作，就是对一个变量进行了读取，符合针对变量操作的原子性。所以是线程安全的

懒汉模式的线程安全

在懒汉模式中，程序首先会判断有没有创建实例，如果没有的话创建实例，随后再返回对象，这一整个操作就不是原子性的，所以不是线程安全的。例如用两个getInstance同时执行，它们在if判断的时候都没有创建实例，这时候就会创建超过一个实例了，很显然在单例模式中这不能被允许。（解决方法加锁）

class Singleton2{
    //懒汉模式，在该模式中不着急创建出实例，在类外需要的时候，我们再进行创建
    public static Singleton2 instance = null;
    private Singleton2(){}
    public static Singleton2 getInstance(){
        synchronized(Singleton2.class) {     //加锁
            if (instance == null) {
                instance = new Singleton2();
            }
        }
        return instance;
    }
}
public class TestDemo3 {
    public static void main(String[] args) {
        Singleton2 singleton2 = Singleton2.getInstance();
    }

但是加锁之后又有了新的问题

如果我们直接在第一行加锁，那么不管这个实例有没有被创建，我们都会让线程串行执行。但是其实并没有必要！！因为如果实例被创建了，懒汉模式下直接就会返回Instance，其实这时候是线程安全的。所以说我们可以做一个小优化，就是首先判断这个实例有没有被创建。

//实现一个线程安全的单例模
class Singleton2{
    //懒汉模式，在该模式中不着急创建出实例，在类外需要的时候，我们再进行创建
    public static Singleton2 instance = null;
    private Singleton2(){}
    public static Singleton2 getInstance(){
        if(instance == null) {  //如果instance被初始化过了，那么就不必再进行加锁，直接返回这个实例即可
            synchronized (Singleton2.class) {
                if (instance == null) {
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }
}
public class TestDemo3 {
    public static void main(String[] args) {
        Singleton2 singleton2 = Singleton2.getInstance();
    }
}

但是实际上这个还是有一点问题（加锁次数会变多，原因未知，解决方法在Singleton2前加volatile关键字，日后深究）

参考网站：https://blog.csdn.net/qq_54883034/article/details/124643393?spm=1001.2014.3001.5506