《javaEE篇》--单例模式详解

总结

单例模式

单例模式属于一种设计模式，设计模式就好比是一种固定代码套路类似于棋谱，是由前人总结并且记录下来我们可以直接使用的代码设计思路。

单例模式就是，在有些场景中希望一个类只能有一个对象，不能有多个，这时你可能会觉得，这还不简单，我保证自己只new一个对象不就好了，但是你能保证自己只new一个对象，但是你能保证别人不会new对象吗？又或者，你真的能确保自己只new一个对象吗？所以“我保证自己只new一个对象不就好了”，这只是一个君子协定，光靠人是非常不靠谱的，所以我们要依靠计算机来帮助我们实现这个协定。

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

单例模式的实现方式可以分为两种，饿汉模式和懒汉模式

饿汉模式

具体实现方法

用static修饰，在类的内部创建一个现成的实例，让对象在在类加载时就被创建
提供一个方法当需要这个对象时就通过这个方法获得
用private修饰构造方法，这样外界就不能实例化这个类了

通过这三个方法就可以保证只有一个该类对象了

java">class Singleton{//创建时时机比较早(饿汉模式)//当类被加载时就会执行这里的创建实例操作private static Singleton instance = new Singleton();//后续需要这个对象，都通过这个方法获取public static Singleton getInstance(){return instance;}//私有构造方法private Singleton(){}
}
public class Demo17 {public static void main(String[] args) {//把构造方法设置为私有，之后就无法实例化这个对象了，这能通过刚刚创建的方法//Singleton singleton = new Singleton();Singleton s1 = Singleton.getInstance();Singleton s2 = Singleton.getInstance();//这两个对象其实是一样的System.out.println(s1 == s2);}
}

通过运行结果我们可以验证，上述在main方法中创建的对象是同一个，也就是刚刚在类中创建的那一个对象

这种方法会在类加载时就把对象创建好，如果不使用就会造成资源浪费

懒汉模式

具体实现

用static修饰，只声明类型创建实际对象
私有构造方法
提供外界用来获得对象的方法，设定当第一次调用方法时才创建对象

java">class SinngletonLazy{//在第一次调用时创建对象(懒汉模式)//只声明一个类型不创建实际对象private static SinngletonLazy instance = null;public static SinngletonLazy getInstance(){//如果是第一次调用，就创建实例对象，否则直接返回对象if(instance == null){instance = new SinngletonLazy();}return instance;}//私有构造方法private SinngletonLazy(){}
}

饿汉模式和懒汉模式的最大区别就是，饿汉模式在类加载时就创建了对象，懒汉模式在第一次调用方法时才创建对象，假如我们要打开一本电子书，饿汉模式是要把整本书都加载完成才可以看，而懒汉模式则是在翻页时才加载下一页，可想而知懒汉模式是更高效的。

懒汉模式(优化)

不过上述实现懒汉模式的方法只在单线程下才适用，如果是在多线程环境下会引起线程安全问题。

这里我来画图解释一下

如果当t1执行到①时，if判定为真，程序将要进到if语句内部，此时t2线程插了进来，由于t1线程还没创建出对象，所以t2线程的if语句也会判定为真，接着t2线程new了一个对象然后返回，最后又回到t1线程这边紧接着又new了一个对象，此时代码就出现问题了。

我们第一时间想到的方法就是直接给方法加上锁，这个方法确实可以解决问题，但是这样的话，代码的并发性就降低了，进而影响到代码的效率，所以我们要换种思路。

可以思考一下，我们的加锁操作只是再第一次创建对象时才需要，所以我们在加锁操作前再加一个if语句来判断当前是否需要加锁，这样就既实现了懒汉模式，又优化了代码的效率

java">class SinngletonLazy{//在第一次调用时创建对象(懒汉模式)//只声明一个类型不创建实际对象private static SinngletonLazy instance = null;public static SinngletonLazy getInstance(){//如果是第一次调用，就加锁创建对象，否则直接返回对象if(instance == null) {//判断是否需要加锁synchronized (SinngletonLazy.class){if (instance == null) {//判断是否需要new对象instance = new SinngletonLazy();}}}return instance;}//私有构造方法private SinngletonLazy(){}
}

用简洁的话总结一下就是，因为为了防止资源浪费，所以使用一个if条件判断是否需要创建对象，因为在多线程下会出现线程安全的问题，所以要加锁，又因为只需要再第一次创建对象时才需要加锁，所以为了提升效率，再加一层if判断当前是否需要加锁(这两个if本质上没有什么关系，只是刚好判断条件一样而已)

这种方法也叫做Double Check(双重检验) + Lock(加锁)

虽然当前的代码已经很完善了但是还是会有指令重排序的问题

指令重排序

指令重排序也是一种编译器的优化，是编译器为了提高效率，在保证代码逻辑顺序不变的情况下，改变代码的实际顺序。

实际上这里的new操作可以分成三个步骤

向内存申请空间
在刚刚申请的空间上构造对象
把刚刚申请的空间的地址付给instance

但是后面两个步骤对于编译器来说是可以颠倒的，按照123或者132来执行都是可以的，就看那种效率快，在单线程下是没有问题的但是在多线程下就会出现问题

假设有t1，t2线程，t1线程执行到new操作之后先执行1，3，此时编译器已经把刚刚申请的内存地址付给instance，Instance此时已经是一个非空的了，也就是说，此时instance指向一个还没有初始化的非法对象。但是这个时候还没有执行2操作，假如这时t2线程开始执行，判定第一个instance==Null，条件不成立(因为刚刚t1线程已经给instance赋值了)，t2线程就直接会返回instance对象。但是此时，t1还没有到内存上构造出对象，T2线程的代码可能就会访问instance里面的属性了，进而就会引起一些bug。

这里可能会有疑问了，刚刚不是给new操作加锁了吗？为什么还会再new操作时插入其他线程？这就是刚刚代码的缺陷之处，我们为了提高效率只是给new操作加锁了，但是此时t2线程只是执行到了第一个if条件，还没有涉及到任何锁操作，就更谈不上阻塞等待了。t2线程此时连第一个if条件都没有进去，就拿着一个还没有初始化的非法对象返回了。

解决方法

不过解决方法也很简单，使用volatile关键字修饰就可以了，volatile可以防止指令重排序，相当于告诉编译器，不要进行代码优化，让它按照本来的顺序执行

此外volatile还有一个作用：保证内存可见性，就是每一时刻线程读取到该变量的值都是内存中最新的那个值(线程每次操作该变量都需要先读取该变量)

最终代码展示：

java">class SinngletonLazy{//在第一次调用时创建对象(懒汉模式)//只声明一个类型不创建实际对象private static volatile SinngletonLazy instance = null;public static SinngletonLazy getInstance(){//如果是第一次调用，就加锁创建对象，否则直接返回对象if(instance == null) {//判断是否需要加锁synchronized (SinngletonLazy.class){if (instance == null) {//判断是否需要new对象instance = new SinngletonLazy();}}}return instance;}//私有构造方法private SinngletonLazy(){}
}