文档章节

Android 设计模式 之 单例模式

hejunbinlan
 hejunbinlan
发布于 2015/09/08 14:41
字数 2496
阅读 89
收藏 3

Singleton模式可以是很简单的,它的全部只需要一个类就可以完成(看看这章可怜的UML图)。但是如果在“对象创建的次数以及何时被创建”这两点上较真起来,Singleton模式可以相当的复杂,比头五种模式加起来还复杂,譬如涉及到DCL双锁检测(double checked locking)的讨论、涉及到多个类加载器(ClassLoader)协同时、涉及到跨JVM(集群、远程EJB等)时、涉及到单例对象被销毁后重建等。

目的:

希望对象只创建一个实例,并且提供一个全局的访问点。

图6.1 单例模式的UML图

结构是简单的,但是却存在一下情况;

1.每次从getInstance()都能返回一个且唯一的一个对象。

2.资源共享情况下,getInstance()必须适应多线程并发访问。

3.提高访问性能。

4.懒加载(Lazy Load),在需要的时候才被构造。


首先实现1中的单例模式A:

[java]  view plain copy
  1. 4.public class SingletonA {    
  2. 5.     
  3. 6.    /**  
  4. 7.     * 单例对象实例  
  5. 8.     */    
  6. 9.    private static SingletonA instance = null;    
  7. 10.     
  8. 11.    public static SingletonA getInstance() {    
  9. 12.        if (instance == null) {                              //line 12    
  10. 13.            instance = new SingletonA();          //line 13    
  11. 14.        }    
  12. 15.        return instance;    
  13. 16.    }    
  14. 17.}    

这个写法我们把四点需求从上往下检测,发现第2点的时候就出了问题,假设这样的场景:两个线程并发调用Singleton.getInstance(),假设线程一先判断完instance是否为null,既代码中的line 12进入到line 13的位置。刚刚判断完毕后,JVM将CPU资源切换给线程二,由于线程一还没执行line 13,所以instance仍然是空的,因此线程二执行了new Signleton()操作。片刻之后,线程一被重新唤醒,它执行的仍然是new Signleton()操作。所以这种设计的单例模式不能满足第2点需求。

下面我们继续


实现2中单例模式B:

[java]  view plain copy
  1. 4.public class SingletonB {    
  2. 5.     
  3. 6.    /**  
  4. 7.     * 单例对象实例  
  5. 8.     */    
  6. 9.    private static SingletonB instance = null;    
  7. 10.     
  8. 11.    public synchronized static SingletonB getInstance() {    
  9. 12.        if (instance == null) {    
  10. 13.            instance = new SingletonB();    
  11. 14.        }    
  12. 15.        return instance;    
  13. 16.    }    
  14. 17.}    

比起单例A仅仅在方法中多了一个synchronized修饰符,现在可以保证不会出线程问题了。但是这里有个很大(至少耗时比例上很大)的性能问题。除了第一次调用时是执行了SingletonKerriganB的构造函数之外,以后的每一次调用都是直接返回instance对象。返回对象这个操作耗时是很小的,绝大部分的耗时都用在synchronized修饰符的同步准备上,因此从性能上说很不划算。


实现3单例模式C:

[java]  view plain copy
  1. 4.public class SingletonC {    
  2. 5.     
  3. 6.    /**  
  4. 7.     * 单例对象实例  
  5. 8.     */    
  6. 9.    private static SingletonKerriganD instance = null;    
  7. 10.     
  8. 11.    public static SingletonC getInstance() {    
  9. 12.        if (instance == null) {    
  10. 13.            synchronized (SingletonC.class) {    
  11. 14.                if (instance == null) {    
  12. 15.                    instance = new SingletonC();    
  13. 16.                }    
  14. 17.            }    
  15. 18.        }    
  16. 19.        return instance;    
  17. 20.    }    
  18. 21.}    

看起来这样已经达到了我们的要求,除了第一次创建对象之外,其他的访问在第一个if中就返回了,因此不会走到同步块中。已经完美了吗?

我们来看看这个场景:假设线程一执行到instance = new SingletonKerriganD()这句,这里看起来是一句话,但实际上它并不是一个原子操作(原子操作的意思就是这条语句要么就被执行完,要么就没有被执行过,不能出现执行了一半这种情形)。事实上高级语言里面非原子操作有很多,我们只要看看这句话被编译后在JVM执行的对应汇编代码就发现,这句话被编译成8条汇编指令,大致做了3件事情:

1.给Kerrigan的实例分配内存。

2.初始化Kerrigan的构造器

3.将instance对象指向分配的内存空间(注意到这步instance就非null了)。

但是,由于Java编译器允许处理器乱序执行(out-of-order),以及JDK1.5之前JMM(Java Memory Medel)中Cache、寄存器到主内存回写顺序的规定,上面的第二点和第三点的顺序是无法保证的,也就是说,执行顺序可能是1-2-3也可能是1-3-2,如果是后者,并且在3执行完毕、2未执行之前,被切换到线程二上,这时候instance因为已经在线程一内执行过了第三点,instance已经是非空了,所以线程二直接拿走instance,然后使用,然后顺理成章地报错,而且这种难以跟踪难以重现的错误估计调试上一星期都未必能找得出来,真是一茶几的杯具啊。

DCL的写法来实现单例是很多技术书、教科书(包括基于JDK1.4以前版本的书籍)上推荐的写法,实际上是不完全正确的。的确在一些语言(譬如C语言)上DCL是可行的,取决于是否能保证2、3步的顺序。在JDK1.5之后,官方已经注意到这种问题,因此调整了JMM、具体化了volatile关键字,因此如果JDK是1.5或之后的版本,只需要将instance的定义改成“private volatile static SingletonKerriganD instance = null;”就可以保证每次都去instance都从主内存读取,就可以使用DCL的写法来完成单例模式。当然volatile或多或少也会影响到性能,最重要的是我们还要考虑JDK1.42以及之前的版本,所以本文中单例模式写法的改进还在继续。

代码倒越来越复杂了,现在先来个返璞归真,根据JLS(Java Language Specification)中的规定,一个类在一个ClassLoader中只会被初始化一次,这点是JVM本身保证的,那就把初始化实例的事情扔给JVM好了.


实现4单例模式D:

[java]  view plain copy
  1. 4.public class SingletonD {    
  2. 5.     
  3. 6.    /**  
  4. 7.     * 单例对象实例  
  5. 8.     */    
  6. 9.    private static SingletonD instance = new SingletonD();    
  7. 10.     
  8. 11.    public static SingletonD getInstance() {    
  9. 12.        return instance;    
  10. 13.    }    
  11. 14.}    


这种写法不会出现并发问题,但是它是饿汉式的,在ClassLoader加载类后Kerrigan的实例就会第一时间被创建,饿汉式的创建方式在一些场景中将无法使用:譬如实例的创建是依赖参数或者配置文件的,在getInstance()之前必须调用某个方法设置参数给它,那样这种单例写法就无法使用了。

可带参数单例模式E:

[java]  view plain copy
  1. 4.public class SingletonE {    
  2. 5.     
  3. 6.    private static class SingletonHolder {    
  4. 7.        /**  
  5. 8.         * 单例对象实例  
  6. 9.         */    
  7. 10.        static final SingletonE INSTANCE = new SingletonE();    
  8. 11.    }    
  9. 12.     
  10. 13.    public static SingletonE getInstance() {    
  11. 14.        return SingletonHolder.INSTANCE;    
  12. 15.    }    
  13. 16.}    


这种写法仍然使用JVM本身机制保证了线程安全问题;由于SingletonHolder是私有的,除了getInstance()之外没有办法访问它,因此它是懒汉式的;同时读取实例的时候不会进行同步,没有性能缺陷;也不依赖JDK版本。

当然,用户以其它方式构造单例的对象,如果设计者不希望这样的情况发生,则需要做规避措施。其它途径创建单例实例的方式有:

1.直接new单例对象

2.通过反射构造单例对象

3.通过序列化构造单例对象。

对于第一种情况,一般我们会加入一个private或者protected的构造函数,这样系统就不会自动添加那个public的构造函数了,因此只能调用里面的static方法,无法通过new创建对象。

对于第二种情况,反射时可以使用setAccessible方法来突破private的限制,我们需要做到第一点工作的同时,还需要在在 ReflectPermission("suppressAccessChecks") 权限下使用安全管理器(SecurityManager)的checkPermission方法来限制这种突破。一般来说,不会真的去做这些事情,都是通过应用服务器进行后台配置实现。

对于第三种情况,如果单例对象有必要实现Serializable接口(很少出现),则应当同时实现readResolve()方法来保证反序列化的时候得到原来的对象。


终极版单例模式F:

[java]  view plain copy
  1. 4.public class SingletonF implements Serializable {    
  2. 5.     
  3. 6.    private static class SingletonHolder {    
  4. 7.        /**  
  5. 8.         * 单例对象实例  
  6. 9.         */    
  7. 10.        static final SingletonF INSTANCE = new SingletonF();    
  8. 11.    }    
  9. 12.     
  10. 13.    public static SingletonF getInstance() {    
  11. 14.        return SingletonHolder.INSTANCE;    
  12. 15.    }    
  13. 16.     
  14. 17.    /**  
  15. 18.     * private的构造函数用于避免外界直接使用new来实例化对象  
  16. 19.     */    
  17. 20.    private SingletonF() {    
  18. 21.    }    
  19. 22.     
  20. 23.    /**  
  21. 24.     * readResolve方法应对单例对象被序列化时候  
  22. 25.     */    
  23. 26.    private Object readResolve() {    
  24. 27.        return getInstance();    
  25. 28.    }    
  26. 29.}    

2、android中源码单例模式举例

1、日历模块 

App路径:packages/providers/CalendarProvider

文件:packages/providers/CalendarProvider/src/com/android/provider/calendar/CalendarDatabaseHelper.java

单例代码:

[java]  view plain copy
  1. private static CalendarDatabaseHelper sSingleton = null;      
  2. public static synchronized CalendarDatabaseHelper getInstance(Context context) {  
  3.         if (sSingleton == null) {  
  4.             sSingleton = new CalendarDatabaseHelper(context);  
  5.         }  
  6.         return sSingleton;  
  7.     }  
可以看出,这是用到了2中的单例模式B.


2.Collator类

文件:libcore/luni/src/main/java/com/ibm/icu4jni/text/Callator.java

libcore/luni/src/main/java/com/ibm/icu4jni/text/RuleBasedCallator.java

单例代码:

[java]  view plain copy
  1. public static Collator getInstance(Locale locale) {  
  2.     return new RuleBasedCollator(locale);  
  3. }  
  4. p;     
[java]  view plain copy
  1.     RuleBasedCollator(Locale locale) {  
  2.         m_collator_ = NativeCollation.openCollator(locale.toString());  
  3.     }  
  4.       
[java]  view plain copy
  1. static native int openCollator(String locale);  

这就是上面给出的单例模式E,可带参数的单例模式


3.Editable类

文件:frameworks/base/core/java/android/text/Editable.java

[java]  view plain copy
  1. private static Editable.Factory sInstance = new Editable.Factory();  
  2.   
  3. /** 
  4.  * Returns the standard Editable Factory. 
  5.  */  
  6. public static Editable.Factory getInstance() {  
  7.     return sInstance;  
  8. }  

可见这是单例模式D是实例应用

4.AccessibilityManager类

文件:frameworks/base/core/java/android/view/accessibility/AccessibilityManager.java

[java]  view plain copy
  1. public static AccessibilityManager getInstance(Context context) {  
  2.     synchronized (sInstanceSync) {  
  3.         if (sInstance == null) {  
  4.             sInstance = new AccessibilityManager(context);  
  5.         }  
  6.     }  
  7.     return sInstance;  
  8. }  

这是单例模式C的应用。

android使用单例模式的地方很多,特别是数据库创建时,就会使用到单例模式。因每种单例模式试用场景不一样,所以android在不同地方使用了不同的单例模式实现方式。

本文转载自:http://blog.csdn.net/liguangzhenghi/article/details/8076361

hejunbinlan
粉丝 41
博文 596
码字总数 21569
作品 0
浦东
高级程序员
私信 提问
Android 架构师9 设计模式之策略模式

前言 策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们之间可以相互替换。这些策略算法是相同行为的不同实现。 需求 三国故事中,刘备要到江东娶孙权的妹妹孙尚香,由于这行...

zhang_pan
2018/04/26
0
0
[Andriod设计模式之旅]——Builder模式

版权声明:本文为博主原创文章,转载请注明出处http://blog.csdn.net/u013132758。 https://blog.csdn.net/u013132758/article/details/78764592 前言 具体介绍Builder设计模式之前,首先我们...

紫雾凌寒
2017/12/10
0
0
Android 网络编程 目录

Android 网络编程 目录 Android 网络编程1 Http协议 Android 网络编程2 Okhttp缓存机制 Android 网络编程3 Java NIO to be continued... Android 架构师之路 目录 Android 架构师之路1 UML图...

香沙小熊
2018/06/21
0
0
移动开发之设计模式- 代理模式(IOS&Android)

资源 完全参照 代理模式|菜鸟教程但不包括IOS代码 代理模式 在代理模式(Proxy Pattern)中,一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。 在代理模式中,我们创建具有现有...

FlanneryZJ
2018/12/18
0
0
Java 设计模式(14) —— 复合模式

一、复合模式 模式常一起使用,组合在一个设计解决方案中 复合模式在一个解决方案中结合两个或多个模式,能解决一般性或一系列的问题 二、示例 本次设计模式讲解中无代码示例,由于复合模式是...

磊_lei
2018/05/26
0
0

没有更多内容

加载失败,请刷新页面

加载更多

一套基于SpringBoot+Vue+Shiro 前后端分离 开发的代码生成器

一、前言 最近花了一个月时间完成了一套基于Spring Boot+Vue+Shiro前后端分离的代码生成器,目前项目代码已基本完成 止步传统CRUD,进阶代码优化: 该项目可根据数据库字段动态生成 controll...

郑清
12分钟前
2
0
javascript-十六进制随机颜色

<script> // 编写一个函数,获得一个十六进制的随机颜色的字符串(如#20CD4F) // function randomColor(){ // var r = random(0,255).toString(16); // var g = random(0,255).toString(16......

ACKo
14分钟前
2
0
springBoot +mybatis 出现sql 语句在数据库可以查询到,但是赋值到实体类上就没有的情况?

1.不要老是反复查看自己是否写错了,为啥有的能出来有的出不来? 可以查看配置文件中是否配置全: 如果在application.yml 文件中是如下配置: mybatis: mapper-locations: classpath:mapp...

kuchawyz
27分钟前
2
0
正则表达式

一、RegExp对象 进行验证和查找的API 1、创建对象: (1)用/创建(直接量):var reg=/正则/ig,表达式固定不变时使用 (2)用new创建:var reg=new RegExp(‘正则’,‘ig’),表达式需要...

wytao1995
27分钟前
2
0
实战限流(guava的RateLimiter)

关于限流 常用的限流算法有漏桶算法和令牌桶算法,guava的RateLimiter使用的是令牌桶算法,也就是以固定的频率向桶中放入令牌,例如一秒钟10枚令牌,实际业务在每次响应请求之前都从桶中获取...

程序员欣宸
28分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部