多线程案例——单例模式

        单例模式是一种常见的设计模式，单例模式能保证某个类在程序中只存在唯⼀⼀份实例,而不会创建出多个实例.

        实现单例模式的方法有很多，这里举例饿汉模式和懒汉模式

        饿汉模式

        饿汉模式是指在加载这个类时，就创建出这个类的唯一实例

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

        饿汉模式通过将实例私有化以及构造方法私有化，仅给外部一个取得这个实例的方法来保证用户在使用这个类时，只能创建一个实例。

        懒汉模式

        懒汉模式是指在加载这个类时，不创建实例，在用户第一次使用时才创建。

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

        在多线程情况下，两种方式的线程安全性        

        饿汉模式在多线程时，只进行了读操作，所有是线程安全的。

        但是懒汉模式，在多线程中进行了读操作和写操作，如果两个线程同时调用getInstance()，就有可能出现两个实例，此时是线程不安全的。

        对懒汉模式的修改

        上面说到，如果两个线程同时调用getInstance()，就会出现问题，在于如果一个线程判断到为null，但是下一时刻这个线程立刻被调走了，另一个线程正常执行完毕，当第一个线程重新开始执行时，就会再生成一个实例，出现问题。所有，我们就需要给判断是否为空，以及生成实例这个部分加锁：

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

        这样，在同一时刻，只能有一个线程对instance进行判断以及赋值。

        虽然加锁可以避免这个问题的产生，但是，加锁也会导致代码的效率下降。

        当instance已经被创建好了的时候，后续的代码依然要竞争锁，就会导致后面的代码执行起来比较慢。

        所以我们可以给外面套一个判断来判断instance是否已经创建好，如果已经创建好了，那么就跳过加锁，这样就可以保证一定的执行效率：

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

        

        但是，这样就没有问题了吗？        

        答案是依然有，这个代码有可能会由于指令重排序而导致问题。

        要知道为什么会发生指令重排序问题，就要知道代码干了什么。在上面的代码里，如果instance==null成立，那么就会调用构造方法，然后返回这个实例。

        在构造方法中，大致可以分为三个部分：

        1.给这个实例开辟一块内存

        2.调用构造方法中的内容来初始化

        3.将这块内存的地址传给实例

        在多线程中，由于指令重排序这样的过程有两种执行方式，分别为123和132。

        当执行方式为123时不会出现问题，但是当执行方式为132时就有可能会出现问题。

        如果t1线程执行完13步骤后被调度走，此时t2线程开始执行getInstance（），那么由于在3中已经将内存的地址传给了实例也就是instance，此时t2就会判断instance==null不成立，就会直接返回instance给t2中调用这个方法的实例，由于还没有执行步骤2，此时instance中数据没有被初始化，那么当t2紧接着使用instance时就会发生错误。

        在这里想要解决这个问题，就需要使用volatile关键字，volatile可以关闭指令重排序，然后上面的过程就不会发生，修改后是这样的：

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

        那么在这样的修改后，此时的懒汉模式已经是线程安全的了。