单例模式(上)---如何优雅地保证线程安全问题

上次帅地问的问题，让小秋学习了很多。这几天小秋恰好学习了一些设计模式的知识，这不，又跑去找帅地探讨一些问题了。

粗糙的同步

小秋：地哥，上次你问的问题，让我收获颇多，这些天我大体研究了下设计模式，帅地有什么指教的吗？

帅地：小子，行啊。那我再考考你得了。

此刻小秋聚精会神着等帅地又会抛出哪些问题.....

帅地：学过单例模式吧？单例模式有多种写法，写一种出来看看。

小秋：好啊，据说单例模式是面试中问的最多的一种模式，对于单例模式的几种的写法，我能够至关熟练哦（有点得意）。

因而，小秋甩手就写了一种懒汉模式的代码出来

public class Singleton {
    private Singleton instance = null;
    //私有构造函数
    private Singleton(){};
    
    public Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
复制代码

懒汉模式：就是等到有线程调用getInstance这个方法时，才来建立对象实例。与懒汉模式相反的是饿汉模式，下篇会讲到。

帅地：够熟练的你，不过你这段代码并不是线程安全的，怎么办？

小秋：嘿嘿，简单，看个人。

public class Singleton {
    private Singleton instance = null;
    //私有构造函数
    private Singleton(){};
    
    //多了个synchronized关键字
    public   synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

复制代码

注：不清楚synchronized关键字的能够看我以前写的文章：线程安全(上)--完全搞懂synchronized(从偏向锁到重量级锁)

双重检测机制

帅地：你刚才的那种线程不安全的写法，你知道是在何时调用这个方法，会出现线程安全问题吗？

小秋：知道了，主要是由于，当这个实例对象还没有被建立过的时候，忽然同时有几个线程来建立，就有可能会出现线程安全问题致使建立了不止一个实例。

可是，若是这个实例已经被安全着建立了以后，之后无论有再多的线程来调用，那么都不会出现线程安全的问题，由于这个if语句里面的代码永远不会被执行。

帅地：分析的很好，那么问题来了。当一个对象被建立以后，之后有线程来调用这个方法，原本能够不用进入同步块也能保证线程安全的，但是，你把synchronized声明在了方法名称前，致使以后该方法的调用都会进入同步快，这样很影响速度。

小秋：原来这样，怪不得我看书本说，不推荐这种作法，那我改一下：

public class Singleton {
    private Singleton instance = null;
    //私有构造函数
    private Singleton(){};
    public   Singleton getInstance() {
        synchronized (Singleton.class) {
            if (instance == null) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}
复制代码

帅地：小秋，你这样其实和上面那个是几乎同样的，由于你把if(instance == null)这句话的判断放在了同步块内，之后有线程调用这个方法，仍是会每次都进入同步块的。

其实，咱们须要的是，当判断到instance != null时，就直接把instance返回了，而不是把这个判断放到同步块里。

小秋：我知道怎么作了。

因而，不一会，小秋劈里啪啦就写好了

public class Singleton {
    private Singleton instance = null;
    //私有构造函数
    private Singleton(){};
    
    //这种是什么鬼方式？
    public   Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class){
                instance = new Singleton();
            }
        }
        return instance;
    }
}
复制代码

帅地：你肯定你这段代码是线程安全的吗？

小秋赶忙在脑子里模拟了一下当实例对象尚未被建立时，有两个进程同时进入了if(instance == null){}代码块中，结果发现这两个对象都会成功建立新的对象实例。

因而，小秋赶忙在同步块中又加了一层if判断。

public class Singleton {
    private Singleton instance = null;
    //私有构造函数
    private Singleton(){};
    
    //双重检测机制
    public   Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class){
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
复制代码

帅地：脑子栋的挺快嘛，这样子基本就能保证线程安全了。嗯，很棒。这种加锁的方法也叫作双重检测机制。

解释说明：当instance==null时，假若有两个线程p1,p2进入了第一个if语句，以后p1进入的同步块中，成功建立了对象实例，这时候论到p2进入同步块，因为同步块还有一层if(instance==null)的判断，又由于此时instance != null了，因此p2没法再建立新的实例对象。

小秋听到帅地夸奖本身，满脸开心....

指令重排的捣蛋

帅地：不过，你这样写，还不算是绝对的线程安全，仍是有可能会出现线程安全问题。你在仔细想一想。

小秋：还会出现线程安全问题？(一脸懵逼)....

一阵绞尽脑汁事后....

小秋：我以为没啥问题啊。

帅地：好吧，你已经写的挺不错了，今天就再让你涨涨知识。

其实这个线程安全的问题，主要是由于对象的建立过程并不是是原子性的。在建立的过程当中，因为指令重排的影响，才致使出现问题的。

所谓指令重排就是改变了指令的执行顺序，例如代码中有两行代码：int a = 10;int b = 20;因为虚拟机指令重排的影响，编译后有可能顺序被改变了，变成这样：int b = 20;int a = 10;

且听我慢慢道来：

当咱们的虚拟机在执行 instance = new Singleton这句代码时，会被分解成如下三个动做来执行：

memory = allocate();//1: 给对象分配内存空间。

ctorInstance(memory);//2: 初始化对象

instance = memory; //3: 把instance变量指向刚刚分配的内存地址。

可是，这三个动做的执行顺序并不是是一成不变的，有可能通过JVM和CPU的优化编译以后，这三个动做的执行顺序发生了改变，变成了这样：

memory = allocate();//1: 给对象分配内存空间。

instance = memory; //3: 把instance变量指向刚刚分配的内存地址

ctorInstance(memory);//2: 初始化对象

如今假设instance== null,且有p1, p2两个线程来调用这个方法。当p1执行完1，3但尚未执行2时，这时instance已经再也不是null了。假如这个时候p2刚刚进入getInstance这个方法，而后执行if(instance == null)的判断语句，这个时候判断的结果会是false，因而p2直接把instance给返回的。

但因为p1尚未执行动做2，此时的对象尚未被初始化，但却已经被p2给返回了。此时，这个被返回的对象出现问题了。

因而，就出现了线程安全问题。

经过volatile来保证指令重排问题

小秋：又涨知识了。

帅地：问题的根源就是指令重排的影响，因此咱们只要保证在建立对象的时候，不要出现指令重排就能够了。

因此说，咱们能够把instance这个变量声明为volatile。代码以下：

public class Singleton {
    private volatile Singleton instance = null;
     //私有构造函数
    private Singleton(){};
    
    public   Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class){
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
复制代码

注：不清楚volatile关键字的能够看我以前写的文章： 线程安全(上)--完全搞懂volatile关键字

这样，只有把instance声明为volatile，那么虚拟机就会保证这三个动做按照顺序执行了，也就不会出现线程安全问题了。

小秋：哇，谢谢地哥的耐心讲解呢。我要给你点个赞。

结束语

这两次的文章都采用对话的模式来写，以后的文章可能会更多的采用文字对话和漫画对话的形式讲，主要是由于如今还没找到比较喜欢的漫画人物，过几天找到了，就尝试用漫画来说。

小伙伴们若是有好的人物推荐，能够经过加我为好友或者公众号后台发给我哦，在此感谢你们的支持。

完

获取更多原创文章，能够关注下个人公众号：苦逼的码农。同时也感谢把文章介绍给更多须要的人。