• 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html
  • 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html

深入理解单例模式

技术杂谈 勤劳的小蚂蚁 3个月前 (02-05) 66次浏览 已收录 0个评论 扫描二维码

初遇设计模式在上个寒假,当时把每个设计模式过了一遍,对设计模式有了一个最初级的了解。这个学期借了几本设计模式的书籍看,听了老师的设计模式课,对设计模式算是有个更进一步的认识。后面可能会不定期更新一下自己对于设计模式的理解。每个设计模式看似很简单,实则想要在一个完整的系统中应用还是非常非常难的。然后我的能力也非常非常有限,代码量也不是很多,只能通过阅读书籍、思考别人的编码经验以及结合自己的编码过程中遇到的问题来总结。
怎么用->怎么用才好->怎么与其他模式结合使用,我想这是每个开发人员都需要逾越的一道鸿沟。

本文主要内容

1 单例模式简介

1.1 定义

保证一个类仅有一个实例,并提供一个访问它的全局访问点。

1.2 为什么要用单例模式呢?

在我们的系统中,有一些对象其实我们只需要一个,比如说:线程池、缓存、对话框、注册表、日志对象、充当打印机、显卡等设备驱动程序的对象。事实上,这一类对象只能有一个实例,如果制造出多个实例就可能会导致一些问题的产生,比如:程序的行为异常、资源使用过量、或者不一致性的结果。

简单来说使用单例模式可以带来下面几个好处:

  •   对于频繁使用的对象,可以省略创建对象所花费的时间,这对于那些重量级对象而言,是非常可观的一笔系统开销;
  •  由于 new 操作的次数减少,因而对系统内存的使用频率也会降低,这将减轻 GC 压力,缩短 GC 停顿时间。

1.3 为什么不使用全局变量确保一个类只有一个实例呢?


我们知道全局变量分为静态变量和实例变量,静态变量也可以保证该类的实例只存在一个。 只要程序加载了类的字节码,不用创建任何实例对象,静态变量就会被分配空间,静态变量就可以被使用了。
但是,如果说这个对象非常消耗资源,而且程序某次的执行中一直没用,这样就造成了资源的浪费。利用单例模式的话,我们就可以实现在需要使用时才创建对象,这样就避免了不必要的资源浪费。 不仅仅是因为这个原因,在程序中我们要尽量避免全局变量的使用,大量使用全局变量给程序的调试、维护等带来困难。

2 单例的模式的实现

通常单例模式在Java语言中,有两种构建方式:

  • 饿汉方式。指全局的单例实例在类装载时构建
  • 懒汉方式。指全局的单例实例在第一次被使用时构建。
不管是那种创建方式,它们通常都存在下面几点相似处:
  • 单例类必须要有一个 private 访问级别的构造函数,只有这样,才能确保单例不会在系统中的其他代码内被实例化;
  • instance 成员变量和 uniqueInstance 方法必须是 static 的。

2.1 饿汉方式(线程安全)

  1.    publicclassSingleton{
  2.       //在静态初始化器中创建单例实例,这段代码保证了线程安全
  3.        privatestaticSingleton uniqueInstance =newSingleton();
  4.        privateSingleton(){}
  5.        publicstaticSingleton getInstance(){
  6.            return uniqueInstance;
  7.        }
  8.    }
所谓 “饿汉方式” 就是说JVM在加载这个类时就马上创建此唯一的单例实例,不管你用不用,先创建了再说,如果一直没有被使用,便浪费了空间,典型的空间换时间,每次调用的时候,就不需要再判断,节省了运行时间。

2.2 懒汉式(非线程安全和synchronized关键字线程安全版本 )

  1. publicclassSingleton{  
  2.      privatestaticSingleton uniqueInstance;  
  3.      privateSingleton(){
  4.      }  
  5.      //没有加入synchronized关键字的版本是线程不安全的
  6.      publicstaticSingleton getInstance(){
  7.          //判断当前单例是否已经存在,若存在则返回,不存在则再建立单例
  8.          if(uniqueInstance ==null){  
  9.              uniqueInstance =newSingleton();  
  10.          }  
  11.          return uniqueInstance;  
  12.      }  
  13. }
所谓 “饿汉方式” 就是说单例实例在第一次被使用时构建,而不是在JVM在加载这个类时就马上创建此唯一的单例实例。
但是上面这种方式很明显是线程不安全的,如果多个线程同时访问getInstance()方法时就会出现问题。如果想要保证线程安全,一种比较常见的方式就是在getInstance() 方法前加上synchronized关键字,如下:
  1.      publicstaticsynchronizedSingleton getInstance(){  
  2.          if(instance ==null){  
  3.              uniqueInstance =newSingleton();  
  4.          }  
  5.          return uniqueInstance;  
  6.      }  
我们知道synchronized关键字偏重量级锁。虽然在JavaSE1.6之后synchronized关键字进行了主要包括:为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升。
但是在程序中每次使用getInstance() 都要经过synchronized加锁这一层,这难免会增加getInstance()的方法的时间消费,而且还可能会发生阻塞。我们下面介绍到的 双重检查加锁版本 就是为了解决这个问题而存在的。

2.3 懒汉式(双重检查加锁版本)

利用双重检查加锁(double-checked locking),首先检查是否实例已经创建,如果尚未创建,“才”进行同步。这样以来,只有一次同步,这正是我们想要的效果。
  1. publicclassSingleton{
  2.    //volatile保证,当uniqueInstance变量被初始化成Singleton实例时,多个线程可以正确处理uniqueInstance变量
  3.    privatevolatilestaticSingleton uniqueInstance;
  4.    privateSingleton(){
  5.    }
  6.    publicstaticSingleton getInstance(){
  7.       //检查实例,如果不存在,就进入同步代码块
  8.        if(uniqueInstance ==null){
  9.            //只有第一次才彻底执行这里的代码
  10.            synchronized(Singleton.class){
  11.               //进入同步代码块后,再检查一次,如果仍是null,才创建实例
  12.                if(uniqueInstance ==null){
  13.                    uniqueInstance =newSingleton();
  14.                }
  15.            }
  16.        }
  17.        return uniqueInstance;
  18.    }
  19. }
很明显,这种方式相比于使用synchronized关键字的方法,可以大大减少getInstance() 的时间消费。
我们上面使用到了volatile关键字来保证数据的可见性,关于volatile关键字的内容可以看我的这篇文章:《Java多线程学习(三)volatile关键字》 
注意: 双重检查加锁版本不适用于1.4及更早版本的Java。 1.4及更早版本的Java中,许多JVM对于volatile关键字的实现会导致双重检查加锁的失效。

2.4 其他方式(枚举)

除了上面说的几种创建方式之外,还有挺多种其他的创建方式这里稍微多提一点使用枚举的方式,其他创建方式我们就不管了,没有什么实质性的作用。
枚举实现单例的优点就是简单,但是大部分应用开发很少用枚举,可读性并不是很高。个人感觉懒汉式(双重检查加锁版本)还是使用挺多的,这种方式的可读性也比较好。
  1. publicenumSingleton{
  2.     //定义一个枚举的元素,它就是 Singleton 的一个实例
  3.    INSTANCE;  
  4.    publicvoid doSomeThing(){  
  5.         System.out.println("枚举方法实现单例");
  6.    }  
  7. }
使用方法:
  1. publicclassESTest{
  2.    publicstaticvoid main(String[] args){
  3.        Singleton singleton =Singleton.INSTANCE;
  4.        singleton.doSomeThing();//output:枚举方法实现单例
  5.    }
  6. }
我们看看下面这两本书对枚举实现单例模式的看法:
《Effective Java 中文版 第二版》
这种方法在功能上与公有域方法相近,但是它更加简洁,无偿提供了序列化机制,绝对防止多次实例化,即使是在面对复杂序列化或者反射攻击的时候。虽然这种方法还没有广泛采用,但是单元素的枚举类型已经成为实现Singleton的最佳方法。 —-《Effective Java 中文版 第二版》
《Java与模式》
《Java与模式》中,作者这样写道,使用枚举来实现单实例控制会更加简洁,而且无偿地提供了序列化机制,并由JVM从根本上提供保障,绝对防止多次实例化,是更简洁、高效、安全的实现单例的方式。

2.5 总结

我们主要介绍到了以下几种方式实现单例模式:
  • 饿汉方式(线程安全)
  • 懒汉式(非线程安全和synchronized关键字线程安全版本)
  • 懒汉式(双重检查加锁版本)
  • 枚举方式
参考:
《Head First 设计模式》
《Effective Java 中文版 第二版》
【Java】设计模式:深入理解单例模式

丨极客文库, 版权所有丨如未注明 , 均为原创丨
本网站采用知识共享署名-非商业性使用-相同方式共享 3.0 中国大陆许可协议进行授权
转载请注明原文链接:深入理解单例模式
喜欢 (0)
[247507792@qq.com]
分享 (0)
勤劳的小蚂蚁
关于作者:
温馨提示:本文来源于网络,转载文章皆标明了出处,如果您发现侵权文章,请及时向站长反馈删除。

您必须 登录 才能发表评论!

  • 精品技术教程
  • 编程资源分享
  • 问答交流社区
  • 极客文库知识库

客服QQ


QQ:2248886839


工作时间:09:00-23:00