目录
单例模式
单例模式属于一种设计模式,设计模式就好比是一种固定代码套路类似于棋谱,是由前人总结并且记录下来我们可以直接使用的代码设计思路。
单例模式就是,在有些场景中希望一个类只能有一个对象,不能有多个,这时你可能会觉得,这还不简单,我保证自己只new一个对象不就好了,但是你能保证自己只new一个对象,但是你能保证别人不会new对象吗?又或者,你真的能确保自己只new一个对象吗?所以“我保证自己只new一个对象不就好了”,这只是一个君子协定,光靠人是非常不靠谱的,所以我们要依靠计算机来帮助我们实现这个协定。
//这一点在很多场景上都需要. 比如 JDBC 中的 DataSource 实例就只需要一个.
单例模式的实现方式可以分为两种,饿汉模式和懒汉模式
饿汉模式
具体实现方法
- 用static修饰,在类的内部创建一个现成的实例,让对象在在类加载时就被创建
- 提供一个方法当需要这个对象时就通过这个方法获得
- 用private修饰构造方法,这样外界就不能实例化这个类了
通过这三个方法就可以保证只有一个该类对象了
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修饰,只声明类型创建实际对象
- 私有构造方法
- 提供外界用来获得对象的方法,设定当第一次调用方法时才创建对象
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语句来判断当前是否需要加锁,这样就既实现了懒汉模式,又优化了代码的效率
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还有一个作用:保证内存可见性,就是每一时刻线程读取到该变量的值都是内存中最新的那个值(线程每次操作该变量都需要先读取该变量)
最终代码展示:
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(){
}
}
总结
饿汉模式:在类加载时创建对象,通过方法直接返回该对象,不会出现并发安全问题
懒汉模式:在第一次需要对象是才会创建对象,但会有并发问题,建议使用Double Check(双重检验) + Lock(加锁) 可以很好的解决问题
为了在多线程环境下防止,疑问指令重排序而导致代码出现问题,要使用volatile修饰对象
以上就是博主对单例模式知识的分享,在之后的博客中会陆续分享有关线程的其他知识,如果有不懂的或者有其他见解的欢迎在下方评论或者私信博主,也希望多多支持博主之后和博客!!🥰🥰
下一篇博客博主将分享有关阻塞队列等知识,还希望多多支持一下!!!😊