多线程--单例模式【懒汉模式和饿汉模式】

设计模式

设计模式好⽐象棋中的 “棋谱”. 红⽅当头炮, ⿊⽅⻢来跳. 针对红⽅的⼀些⾛法, ⿊⽅应招的时候有⼀些固定的套路. 按照套路来⾛局势就不会吃亏.
软件开发中也有很多常⻅的 “问题场景”. 针对这些问题场景, ⼤佬们总结出了⼀些固定的套路. 按照这个套路来实现代码, 也不会吃亏.
设计模式属于咱们程序员需要掌握的一个技能，设计模式有很多种（不仅仅只有23种）

单例模式

单例模式能够保证某个类在程序中只存在唯一一个实例，而不会创建出多个实例

这一点在很多场景都会需要比如JDBC中的DataSource实例就只需要一个

单例模式具体的实现方式又有很多，最常见的是“饿汉”和“懒汉”两种

饿汉模式

1.创建一个类，期望这个类有唯一实例

class Singleton {
}

2.创建唯一实例的引用

private static Singleton instance = new Singleton();

这里的Static是静态的，指的是“类对象”，instance 就是Singleton类对象里面持有的属性，每个类的类对象只存在一个，类对象中的static属性，自然也就只有一个，所以instance指向的这个对象就是唯一的一个对象。
3.创建其他类能获取该类的方法

public static Singleton getInstance(){
return instance;
}

其他类想要获取这个类就不能new新的方法
3.创建其他代码无法new新的对象

private Singleton （）{
}

完整代码：

class Singleton{
    private static Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
    private Singleton(){

    }
}
public class Test5 {

    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();

            System.out.println(s1 == s2);

    }
}

运行结果：

true

说明s1和s2是同一个实例
上述代码，称为“饿汉模式”单例模式中一种简单的写法
所谓“饿”就是急切的意思
实例是在类加载的时候就创建了，创建时机非常早，相当于程序一启动，实例就创建了，就使用“饿汉”来形容创建实例非常早

懒汉模式

与饿汉模式创建时间不一样，只有第一次使用时在会被创建
1.创建一个类，期望这个类有唯一实例

class SingletonLazy{
}

2.创建一个引用指向唯一实例，初始化为null，不是立即创建实例

private static SingletonLazy instance = null;

3.创建一个方法，用于其他类获取该类的实例

public static SingletonLazy getInstance(){
if(instance == null){
instance = new SingletonLazy();
}
return instance;
}

3.创建其他代码无法new新的对象

private Singleton （）{
}

完整代码：

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

饿汉和懒汉模式线程安全问题

饿汉模式线程安全吗？如果在多个线程中，并发的调用getInstance，饿汉模式线程安全吗？

饿汉模式线程是安全的，对于饿汉来说，getInstance直接返回Instance实例，这个操作本质上是读操作，多个线程读取同一个变量，线程是安全的。

懒汉模式线程不是安全的

此时如果想要代码正确执行，就要把if和new打包成原子，使用锁synchronized

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

但是还是存在一些问题，如果Instance已经创建过了，此时后续再调用getInstance就都是直接返回Instance实例，此处都是读操作，不会有线程安全问题，对于没有线程安全的代码，每次调用还加锁，效率就很低，加锁就意味着可能会产生阻塞，所以此时就可以在外面加一层if语句，判断是否要加锁

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

代码解释：第一个if判定是否要加锁，第二个if判定是否要创建对象

但是该代码还是存在问题
指令重排序引起的线程安全问题，

instance = new SingletonLazy( );

这行代码其实可以分成三个大的步骤
1.申请一段内存空间
2.在这个内存上调用构造方法，创建实例
3.把这个内存地址赋值给Instance引用变量
正常情况下，上述代码是按照1 2 3的顺序执行的
但是编译器也可能优化成1 3 2的顺序来执行
在单线程中无论是1 2 3 还是 1 3 2 都是可以的
多线程就可能出现错误

上述代码，由于t1线程执行完1 3之后，调用走，此时instance指向的是一个非null的，但是未初始化的对象，此时t2线程判定instance==null不成立，就会直接return 如果t2继续使用instance里面的属性或者方法，就会出现问题（此时这里面的属性都是未初始化的“全0”值），就可能会引起代码的逻辑出现问题

解决上述的问题核心思路还是volatile
volatile的两个功能
1.保证内存可见性，每次访问变量必须都要重新读取内存，而不会优化到寄存器/缓存中
2.禁止指令重排序，针对这个用volatile修饰的变量的读写操作的相关指令是不能被重排序的
修改后的代码如下：

class SingletonLazy {
    // 这个引用指向唯一实例. 这个引用先初始化为 null, 而不是立即创建实例
    private volatile static SingletonLazy instance = null;
    private static Object locker = new Object();

    public static SingletonLazy getInstance() {
        // 如果 Instance 为 null, 就说明是首次调用, 首次调用就需要考虑线程安全问题, 就要加锁.
        // 如果非 null, 就说明是后续的调用, 就不必加锁了.
        if (instance == null) {
            synchronized (locker) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }

    private SingletonLazy() { }
}