面试官:不使用synchronized和lock,如何实现一个线程安全的单例?

 
单例,大家肯定都不陌生,这是Java中很重要的一个设计模式。稍微了解一点单例的朋友也都知道实现单例是要考虑并发问题的,一般情况下,我们都会使用synchronized来保证线程安全。
那么,如果有这样一道面试题:不使用synchronized和lock,如何实现一个线程安全的单例? 你该如何回答?
C类应聘者:可以使用饿汉模式实现单例。如:
  1. public class Singleton { 
  2.     private static Singleton instance = new Singleton();
  3.     private Singleton (){}
  4.     public static Singleton getInstance() {
  5.       return instance;
  6.     }
  7. }
还有部分程序员可以想到饿汉的变种:
  1. public class Singleton {
  2.     private Singleton instance = null;
  3.     static {
  4.         instance = new Singleton();
  5.     }
  6.     private Singleton (){}
  7.     public static Singleton getInstance() {
  8.         return this.instance;
  9.     }
  10. }
使用static来定义静态成员变量或静态代码,借助Class的类加载机制实现线程安全单例。
面试官:除了这种以外,还有其他方式吗?
B类应聘者:
除了以上两种方式,还有一种办法,就是通过静态内部类来实现,代码如下:
  1. public class Singleton {
  2.     private static class SingletonHolder {
  3.         privatestaticfinalSingleton INSTANCE = newSingleton();
  4.     }
  5.     privateSingleton (){}
  6.     publicstaticfinalSingleton getInstance() {
  7.         returnSingletonHolder.INSTANCE;
  8.     }
  9. }
这种方式相比前面两种有所优化,就是使用了lazy-loading。Singleton类被装载了,但是instance并没有立即初始化。因为SingletonHolder类没有被主动使用,只有显示通过调用getInstance方法时,才会显示装载SingletonHolder类,从而实例化instance。
面试官:除了这种以外,还有其他方式吗?
A类应聘者:
除了以上方式,还可以使用枚举的方式,如:
  1. public enum Singleton {
  2.     INSTANCE;
  3.     public void whateverMethod() {
  4.     }
  5. }
这种方式是Effective Java作者Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象,可谓是很坚强的壁垒。
面试官:以上几种答案,其实现原理都是利用借助了类加载的时候初始化单例。即借助了ClassLoader的线程安全机制。
所谓ClassLoader的线程安全机制,就是ClassLoader的loadClass方法在加载类的时候使用了synchronized关键字。也正是因为这样, 除非被重写,这个方法默认在整个装载过程中都是同步的,也就是保证了线程安全。
所以,以上各种方法,虽然并没有显示的使用synchronized,但是还是其底层实现原理还是用到了synchronized。
面试官:除了这种以外,还有其他方式吗?
A类应聘者:
还可以使用Java并发包中的Lock实现
面试官:本质上还是在使用锁,不使用锁的话,有办法实现线程安全的单例吗?
A+类面试者:
有的,那就是使用CAS。
CAS是项乐观锁技术,当多个线程尝试使用CAS同时更新同一个变量时,只有其中一个线程能更新变量的值,而其它线程都失败,失败的线程并不会被挂起,而是被告知这次竞争中失败,并可以再次尝试。实现单例的方式如下:
  1. public class Singleton {
  2.     private static finalAtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>();
  3.     private Singleton() {}
  4.     public static Singleton getInstance() {
  5.         for (;;) {
  6.             Singleton singleton = INSTANCE.get();
  7.             if (null != singleton) {
  8.                 return singleton;
  9.             }
  10.             singleton = new Singleton();
  11.             if (INSTANCE.compareAndSet(null, singleton)) {
  12.                 return singleton;
  13.             }
  14.         }
  15.     }
  16. }
面试官:这种方式实现的单例有啥优缺点吗?
A++类面试者:
用CAS的好处在于不需要使用传统的锁机制来保证线程安全,CAS是一种基于忙等待的算法,依赖底层硬件的实现,相对于锁它没有线程切换和阻塞的额外消耗,可以支持较大的并行度。
CAS的一个重要缺点在于如果忙等待一直执行不成功(一直在死循环中),会对CPU造成较大的执行开销。
另外,如果N个线程同时执行到singleton = new Singleton();的时候,会有大量对象创建,很可能导致内存溢出。
面试官:你被录取了!
本站所有文章均由网友分享,仅用于参考学习用,请勿直接转载,如有侵权,请联系网站客服删除相关文章。若由于商用引起版权纠纷,一切责任均由使用者承担
极客文库 » 面试官:不使用synchronized和lock,如何实现一个线程安全的单例?

Leave a Reply