单例模式
设计模式的概念
设计模式好比象棋中的"棋谱".红方当头炮,黑方马来跳.针对红方的一些走法,黑方应招的时候有一些固定的套路.按照套路来走局势就不会吃亏.
软件开发中也有很多常见的"问题场景".针对这些问题的场景,大佬们总结出了一些固定的套路.按照这些套路来实现代码,也不会吃亏
单例模式概念
单例 = 单个实例(对象)
具体来说,就是某个类,在一个进程中,只应该创建出一个实例.(也就是原则上不应该有多个)
使用单例模式,就可对代码进行更严格的校验与检查.
期望让机器(编译器)能够对代码中指定的类,创建的实例个数,进行校验.如果发现创建多个实例了,就直接让编译器报错这种~~
这一点在很多场景上都需要,一般就是一个对象持有(管理)大量数据时,比如JDBC中的DataSource实例只需要一个.
单例模式具体的实现方式有很多.最常见的是"饿汉"和"懒汉"两种.
饿汉模式
类加载的同时,创建实例.
也就是说实例在类加载的时候就创建了,创建时机非常早,相当于程序一启动,实例就创建了.
class Singleton {private static Singleton instance = new Singleton();private Singleton(){}public static Singleton getInstance() {return instance;}
}public class TestSingleton {public static void main(String[] args) {Singleton.getInstance();Singleton s = new Singleton();}
}1.instance是Singleton类对象里持有的属性.类对象是指Singleton.class(就是从.class加载至内存中,表示类的一个数据结构).
2.private Singleton() {} 是在设置私有构造方法,保证其它代码不能创建出新的对象.
比如:Singleton s = new Singleton();在这里就无法执行
3.其它代码如果想要获得这个类的唯一实例,就可以通过getInstance()方法获取.
对于饿汉来说,getInstance直接返回Instance实例,这个操作本质上是"读操作",多个线程读取同一个变量,是线程安全的.
懒汉模式-单线程版
类加载的时候不创建实例.第一次使用的时候才创建实例.
class Singleton {private static Singleton instance = null;//这个引用先初始化为null,而不是立即创建实例.private Singleton() {}public static Singleton getInstance() {if(instance == null) {instance = new Singleton();}return instance;}
}在这个代码中,首次调用getInstance时,instance引用为null.进入里面的if条件,把实例创建出来.如果后续再次调用,if就不进入.而是直接返回之前创建的引用了.
这样设定,仍可以保证该类的实例是唯一一个.于此同时,创建实例的时机就不是程序驱动的了,而是第一次调用getInstance时(操作执行时机看程序具体需求.大概率要比饿汉这种方式要晚一些,甚至有可能整个程序压根用不到这个方法,也就把创建的操作给省下了).
注意:懒汉模式是比饿汉模式更好一些的.
在计算机中,懒的思想非常有意义:
比如有一个非常大的文件(10GB).有一个编辑器,使用编辑器打开这个文件.
如果是按照"饿汉模式",编辑器就会先把这10GB的数据加载到内存中,然后再进行统一的展示.(即使加载了这么多数据,用户还得一点一点看,没法一下子看完这么多..)
如果是按照"懒汉模式",编辑器就会只读取一小部分数据(比如只读10KB),把这10KB先展示出来.随着用户进行翻页之类的操作,再继续读后续的数据.
懒汉模式-多线程版
上面的懒汉模式是线程不安全的.
线程安全发生在首次创建实例时.如果在多个线程中同时调用getInstance方法,就可能导致创建出多个实例.
一旦实例已经创建好了,后面再多线程环境调用getInstance就不再有线程安全问题了(不再修改Instance了).
举个例子:
譬如这种情况,两次的if条件都符合,会创建两个实例,显然不符合规定.
而这时就很容易想到使用synchronized来解决这个问题.
class Singleton {private static Object locker = new Object();private static Singleton instance = null;private Singleton() {}public static Singleton getInstance() {synchronized(locker) {if(instance == null) {instance = new Singleton();}}return instance;}
}这样写确实可以解决线程安全的问题.但还是有一个问题:
比如Instance已经创建过了.此时后续再调用getInstance就都是返回Instance实例了吧(于是此处的操作就是纯粹的读操作了,也就不会有线程安全问题了).
此时,针对这个已经没有线程安全问题的代码,仍然时每次调用都先加锁再解锁,此时效率就非常低了!!!(加锁意味着会产生阻塞,一旦线程阻塞,啥时候能解除,就不知道了.你可以认为:只要一个代码里加锁了,基本注定就要和"高性能"无缘).
因此我们说,在不该加锁的时候是不能乱加的.
解决方案:可以在加锁外面再套一层if,以判断是否加锁.(如果instance为null,说明是首次调用,首次调用就需要考虑线程安全问题->要加锁 / 如果非null,说明是后续调用->不必加锁)
再来看一下修改的代码:
class Singleton {private static Object locker = new Object();private static Singleton instance = null;private Singleton() {}public static Singleton getInstance() {if (instance == null) {//第一个if判定的是是否加锁(保证执行效率)synchronized(locker) {if(instance == null) {//第二个if判定的是是否要创建对象(保障线程安全)instance = new Singleton();}}}return instance;}
}但是又双有一个问题,就是指令重排序引起的线程安全问题.
我们知道,指令重排序,也是编译器优化的一种方式.(调整原有代码的执行顺序,保证逻辑不变的前提下,提高程序的效率).
这里指的就是instance = new Singleton();
这条语句可以拆分成多个指令:(1)申请一段内存空间 (2)在内存上调用构造方法,创建出这个实例 (3)把这个内存地址赋给Instance引用变量
正常情况下:是按照(1)(2)(3)顺序执行的,但编译器也可优化成(1)(3)(2)执行,多线程指令重排序可能有问题.
原因如下:
解决方案:给instance加上volatile(volatile可以防止指令重排序).
加上之后,针对这个变量的读写操作,就不会出现指令重排序了.
最后代码如下:
class Singleton {private static Object locker = new Object();private static volatile Singleton instance = null;private Singleton() {}public static Singleton getInstance() {if (instance == null) {//第一个if判定的是是否加锁(保证执行效率)synchronized(locker) {if(instance == null) {//第二个if判定的是是否要创建对象(保障线程安全)instance = new Singleton();}}}return instance;}
}
