面试官:你简历上有熟习设计模式,那你给我说一下单例模式实现及线程安全吧
前言
单例应用的太广泛,大家应该都用过,本文主要是想聊聊线程安全的单例以及反序列化破坏单例的情况。
1、概念
确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。
关键点:
- 私有化构造函数
- 通过一个静态方法或者枚举返回单例类对象
- 确保单例类的对象有且只有一个,尤其是多线程环境下
- 确保单例类对象在反序列化时不会重新构建对象
2、实现
2.1、线程安全的单例
2.1.2、饿汉模式
饿汉模式:不论有没有调用getInstance方法,只需类加载了,我就给你new出来(a)
public class A { private static final A a = new A(); public static A getInstance() { return a; } private A() {}}以下两点保证了以上代码的线程安全:
- 调用一个类的静态方法的时候会触发类的加载(假如类没加载过)
- 类只会加载(被加载到虚拟机内存的过程,包括5个阶段)一次
- static变量在类初始化的时候(类加载过程的最后一个阶段)会去赋值静态变量
2.1.2、懒汉模式
懒汉模式:推迟加载,用到再去new
public class B { private static volatile B b; public static synchronized B getInstance() { if (b == null) { b = new B(); } return b; } private B() { }}要保证线程安全,最简单的方式是加同步锁。synchroized保证了多个线程串行的去调用getInstance(),既然是串行,那就不会存在什么线程安全问题了。但是这实现,每次读都要加锁,其实我们想要做的只是让他写(new)的时候加锁。
2.1.3、Double Check Lock (DCL)
public class B { private static volatile B b; public static synchronized B getInstance0() { if (b == null) { synchronized (B.class) { b = new B(); } } return b; } public static B getInstance() { if (b == null) { synchronized (B.class) { if (b == null) { b = new B(); } } } return b; } private B() { }}为理解决懒汉模式的效率问题,我们改造成getInstance0():
但还有个问题 X、Y 两个线程同时进入if (b == null), X先进同步代码块,new了一个B,返回。Y等到X释放锁之后,它也进了同步代码块,也会new一个B。
getInstance0()处理了效率问题,但它不是线程安全的。我们有进行了一次改造: getInstance():
getInstance在同步块里面,又做了一次if (b == null)的判断,确保了Y线程不会再new B,保证了线程安全。
getInstance() 也正是所谓的双重检查锁定(double checked locking)。
这里还有一个关键点:private static volatile B b; b是用volatile修饰的。
这个主要是由于new 并不是原子的。
B b = new B();可以简单的分解成一下步骤
- 分配对象内存
- 初始化对象
- 设置引用指向分配的内存地址
2,3 直接可能发生指令重排序,就是说对象还未初始化完成,就让b指向了一块内存地址,这时候b就不是null了。
2.1.4、静态内部类单例模式
public class C { private C() {} public static C getInstance() { return CHolder.c; } private static class CHolder { private static final C c = new C(); }}静态内部类的线程安全也是由jvm保证的,在调用Cholder.c的时候,去加载CHolder类,new 了一个c。
总的来说,这个方式比DCL还是高点的,由于DCL加了volatile,效率上还是稍微有些些影响。
上面详情的3种线程安全的单例,在有种极端的情况,单例模式有可能被破坏:反序列化
- Java序列化就是指把Java对象转换为字节序列的过程
- Java反序列化就是指把字节序列恢复为Java对象的过程。
反序列化的时候,会重新构造一个对象,破坏单例模式。我们看下代码验证下:
public class C1 implements Serializable { private C1() { System.out.println("构造方法"); } public static C1 getInstance() { return CHolder.c; } private static class CHolder { private static final C1 c = new C1(); }// 注意这块被注释的代码// private Object readResolve(){// System.out.println("read resolve");// return CHolder.c;// } public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { C1 c = C1.getInstance(); System.out.println(c.toString()); try { ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("d:/tmp/c.out")); o.writeObject(c); o.close(); } catch(Exception e) { e.printStackTrace(); } C1 c1 = null, c2 = null; try { ObjectInputStream in =new ObjectInputStream( new FileInputStream("d:/tmp/c.out")); c1 = (C1)in.readObject(); in.close(); } catch(Exception e) { e.printStackTrace(); } try { ObjectInputStream in =new ObjectInputStream( new FileInputStream("d:/tmp/c.out")); c2 = (C1)in.readObject(); in.close(); } catch(Exception e) { e.printStackTrace(); } System.out.println("c1.equals(c2) : " + c1.equals(c2)); System.out.println("c1 == c2 : " + (c1 == c2)); System.out.println(c1); System.out.println(c2); }}结果:
构造方法me.hhy.designpattern.singletonpattern.C1@1540e19dc1.equals(c2) : falsec1 == c2 : falseme.hhy.designpattern.singletonpattern.C1@135fbaa4me.hhy.designpattern.singletonpattern.C1@45ee12a7放开注释的代码
构造方法me.hhy.designpattern.singletonpattern.C1@1540e19dread resolveread resolvec1.equals(c2) : truec1 == c2 : trueme.hhy.designpattern.singletonpattern.C1@1540e19dme.hhy.designpattern.singletonpattern.C1@1540e19d正如我们看到的那样,加上readResolve就处理了反序列化单例被破坏的问题。
当然,假如没实现Serializable接口,也就不会有这个被破坏的问题… 还是看场景。
关于readResolve的详情,感兴趣的同学们可以看java.io.ObjectInputStream#readUnshared方法上的注释(博主看了,看得不是很明白,一知半解,就不误人子弟了)
而我们下面要详情的枚举单例,并不会有这个问题。
2.1.5、枚举单例
public enum DEnum { INSTANCE; private D d; DEnum() { d = new D(); } public D getInstance() { return d; }}public class D {}线程安全的保证:
- 枚举只能拥有私有的构造器
- 枚举类实际上是一个继承Enum的一个final类
- 上面的INSTANCE实际是被static final 修饰的
序列化不破坏单例的保证:
在序列化的时候Java仅仅是将枚举对象的name属性输出到结果中,反序列化的时候则是通过java.lang.Enum的valueOf方法来根据名字查找枚举对象。同时,编译器是不允许任何对这种序列化机制的定制的,因而禁用了writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法。
2.2 线程不安全的单例
2.2.1、懒汉模式
不过多详情了,这个其实在线程安全的单例部分,我们详情的比较详细了。
public class B { private static volatile B b; public static B getInstance() { if (b == null) { b = new B(); } return b; } private B() { }}3. 总结
单例的应用实在是太多了,也没必要再去找源码种的经典使用(由于基本上大家用过)。
枚举单例构造方法还是public,并不是防止外部直接去new它。个人认为假如一个类要开放给外部使用,用内部类的形式实现单例是最合适的。
最后
感谢你看到这里,看完有什么的不懂的可以在评论区问我,觉得文章对你有帮助的话记得给我点个赞,每天都会分享java相关技术文章或者行业资讯,欢迎大家关注和转发文章!
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » 面试官:你简历上有熟习设计模式,那你给我说一下单例模式实现及线程安全吧