【Java EE初阶六】多线程案例（单例模式）

1. 单例模式

单例模式是一种设计模式，设计模式是我们必须要掌握的一个技能；

1.1 关于框架和设计模式

设计模式是软性的规定，且框架是硬性的规定，这些都是技术大佬已经设计好的；

一般来说设计模式有很多种，且不同的语言会有不同的设计模式，（同时设计模式也可以理解为对编程语言的一种补充）

1.2 细说单例模式

单例 = 单个实例（对象）；

某个类，在一个线程中，只应该创建一个实例化对象（原则上不应该有多个），这时就使用单例模式，如此可以对我们的代码进行一个更严格的校验和检查。

保证对象唯一性的方法：

方法一，可以通过“协议约束”，写一个文档，规定这个类只能有唯一的实例，程序员在接手这个代码时，就会发现这个文档已经进行约定，其中的规定约束着程序员在创建对象时，时刻注意只能创建一个对象。

方法二：从机器入手；让机器帮我们检查，我们期望让机器帮我们对代码中指定的类，创建类的实例个数进行检查、校验，当创建的实例个数超过我们期望个数，就编译报错。其中单例模式就是已经设计好的套路，可以实现这种预期效果。

关于单例模式代码实现的基本方式有两种：饿汉模式和懒汉模式；

2. 饿汉模式

饿汉模式是指创建实例的时期非常早；在类加载的时候，程序一启动，就已经创建好实例了，使用 “饿汉”这个词，就是形容创建实例非常迫切，非常早。单例模式代码如下：

class Singleton {
    private static Singleton instance = new Singleton();
    public static Singleton getInstance() {
        return instance;
    }
    private Singleton(){ }
}
public class TestDemo4 {
    public static void main(String[] args) {
        Singleton singleton = new Singleton();
    }
}

当我们运行该代码时，系统就会报错，接下来我们详细的分析一下此处的代码；

这样，如果我们想new一个Singleton对象，也new不了，同时不管我们用getInstance获取多少次实例，获取的对象都是同一个对象，代码如下：

package thread;

// 就期望这个类只能有唯一的实例 (一个进程中)
class Singleton {
    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }

    private Singleton() {}
}

public class ThreadDemo26 {
    public static void main(String[] args) {
        // Singleton s = new Singleton();
        Singleton s = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s == s2);
    }
}

结果如下：

3. 懒汉模式

和饿汉模式不一样的是，懒汉模式创建实例的时机比较晚，没饿汉创建实例那么迫切，只有第一次使用这个类时，才会创建实例，代码如下：

class SingletonLazy {
    private static SingletonLazy instance = null;
    public static SingletonLazy getInstance() {
        if(instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
    private SingletonLazy() { }
}
public class TestDemo5 {
    public static void main(String[] args) {
 
    }
}

下面为代码图解分析：

和饿汉模式的区别就是没那么迫切创建实例，等需要调用这个类的时候才创建一个实例，而饿汉模式是有了这个类就创建出实例。

懒汉模式的优点：有的程序，要在一定条件下，才需要进行相关的操作，有时候不满足这个条件，也就不需要完成这个操作了，如此哦·就把这个操作省下来了。

4. 两种模式关于线程安全

4.1 饿汉模式

线程安全；

对于饿汉模式来说，上图所示通过调用getinstance方法来返回instance对象，本质上来说是读操作；

当有多个线程，同时并发执行，调用getInstance方法，取instance，这时线程是安全的，因为只涉及到读，多线程读取同一个变量，是线程安全的。而instance很早之前就已经创建好了，不会修改它，一直也只有这一个实例，也不涉及写的操作。

4.2 懒汉模式

线程不安全；

在懒汉模式中，条件判定和返回时是读操作，new一个对象是写操作；

我们只有调用getInstance方法后，就会创建出实例来，如果多个线程同时调用这个方法，此时SingletonLazy类里面的instance都为null，那么这些线程都会new对象，就会创建多个实例。这时，就不符合我们单例模式的预期了，所以，这个代码是线程不安全的。

线程不安全的直接原因，就是 “写” 操作不是原子的。

4.3 解决懒汉模式的线程安全问题

4.3.1 把写操作打包成原子

因为多线程并发执行的时候，可能读到的都是instance == null，所以会创建多个实例，那我们就给它加锁，让它在创建实例的时候，只能创建一个，加锁代码如下：

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

以上操作虽然将写操作打包成了一个原子，但是新的问题也出现了；

4.3.2 去除冗余操作

上述操作加上了还是有问题：如果已经创建出实例了，我们还有加锁来判断它是不是null吗，加锁这些操作也是要消耗硬件资源的，没有必要为此浪费资源空间，如果已经不是null了，我们就想让它直接返回，不再进行加锁操作，代码修改如下：

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

代码图解分析两个判断语句的是目的意义：

4.3.3 指令重排序的问题

指令重排序：指令重排序也是编译器的一种优化，在保证原代码的逻辑不变，调整原代码的指令执行顺序，从而让程序的执行效率提高。

保证原代码的逻辑不变，改变原有指令的顺序，从而提高代码的执行效率，其中这个代码，就存在着指令重排序的优化，如下图代码：

该语句原本指令执行顺序：

        1、去内存申请一段空间

        2、在这个内存中调用构造方法，创建实例

        3、从内存中取出地址，赋值给这个实例instance。

指令重排序后的顺序：1, 3 , 2；按照指令重排序后的代码执行逻辑就变成了下面所示：

        假设有两个线程，现在执行顺序如下图所示：

        因为指令重排序后，先去内存申请一段空间，然后是赋值给instance，那这时，instance就不是null了，第二个线程不会进入到if语句了，直接返回instance，可是instance还没有创建出实例，这样返回肯定是有问题的，如此也就线程不安全了。

        解决方案：

        给instance这个变量，加volatile修饰，强制取消编译器的优化，不能指令重排序，同时也排除了内存可见性的问题。

        加volatile后的代码如下：
class SingletonLazy {
    private static Object locker = new Object();
    private static volatile SingletonLazy instance = null;
    public static SingletonLazy getInstance() {
        if (instance == null) {
            synchronized (locker) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
    private SingletonLazy() { }
}
至此，我们才算解决掉懒汉模式关于线程安全的所有问题；

4.4 懒汉模式线程安全的代码

package thread;

// 懒汉的方式实现单例模式.
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() { }
}

public class ThreadDemo27 {
    public static void main(String[] args) {
        SingletonLazy s1 = SingletonLazy.getInstance();
        SingletonLazy s2 = SingletonLazy.getInstance();
        System.out.println(s1 == s2);
    }
}

结果如下：