Android 设计模式 之 单例模式

http://blog.csdn.net/fangchongbory/article/details/7734199

目录(?)[+]

  1. 单例模式常见情景
    1. 首先实现1中的单例模式A
    2. 实现2中单例模式B
    3. 实现3单例模式C
    4. 实现4单例模式D
    5. 可带参数单例模式E
    6. 终极版单例模式F
  2. android中源码单例模式举例
    1. 日历模块
    2. Collator类
    3. Editable类
    4. AccessibilityManager类

1、单例模式常见情景

设计模式中，最简单不过的就是单例模式。先看看单例模式

原文：http://www.iteye.com/topic/575052

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 plaincopyprint?

  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.}
4.public class SingletonA {
5.
6.    /**
7.     * 单例对象实例
8.     */
9.    private static SingletonA instance = null;
10.
11.    public static SingletonA getInstance() {
12.        if (instance == null) {                              //line 12
13.            instance = new SingletonA();          //line 13
14.        }
15.        return instance;
16.    }
17.}

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

下面我们继续

实现2中单例模式B：

[java] view plaincopyprint?

  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.}
4.public class SingletonB {
5.
6.    /**
7.     * 单例对象实例
8.     */
9.    private static SingletonB instance = null;
10.
11.    public synchronized static SingletonB getInstance() {
12.        if (instance == null) {
13.            instance = new SingletonB();
14.        }
15.        return instance;
16.    }
17.}

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

实现3单例模式C：

[java] view plaincopyprint?

  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.}
4.public class SingletonC {
5.
6.    /**
7.     * 单例对象实例
8.     */
9.    private static SingletonKerriganD instance = null;
10.
11.    public static SingletonC getInstance() {
12.        if (instance == null) {
13.            synchronized (SingletonC.class) {
14.                if (instance == null) {
15.                    instance = new SingletonC();
16.                }
17.            }
18.        }
19.        return instance;
20.    }
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 plaincopyprint?

  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.}
4.public class SingletonD {
5.
6.    /**
7.     * 单例对象实例
8.     */
9.    private static SingletonD instance = new SingletonD();
10.
11.    public static SingletonD getInstance() {
12.        return instance;
13.    }
14.}

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

可带参数单例模式E:

[java] view plaincopyprint?

  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.}
4.public class SingletonE {
5.
6.    private static class SingletonHolder {
7.        /**
8.         * 单例对象实例
9.         */
10.        static final SingletonE INSTANCE = new SingletonE();
11.    }
12.
13.    public static SingletonE getInstance() {
14.        return SingletonHolder.INSTANCE;
15.    }
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 plaincopyprint?

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

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

1、日历模块

App路径:packages/providers/CalendarProvider

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

单例代码：

[java] view plaincopyprint?

  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. }
private static CalendarDatabaseHelper sSingleton = null;
public static synchronized CalendarDatabaseHelper getInstance(Context context) {
        if (sSingleton == null) {
            sSingleton = new CalendarDatabaseHelper(context);
        }
        return sSingleton;
    }

可以看出，这是用到了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 plaincopyprint?

  1. public static Collator getInstance(Locale locale) {
  2. return new RuleBasedCollator(locale);
  3. }
  4. p;
    public static Collator getInstance(Locale locale) {
        return new RuleBasedCollator(locale);
    }
    

[java] view plaincopyprint?

  1. RuleBasedCollator(Locale locale) {
  2. m_collator_ = NativeCollation.openCollator(locale.toString());
  3. }
    RuleBasedCollator(Locale locale) {
        m_collator_ = NativeCollation.openCollator(locale.toString());
    }
    

[java] view plaincopyprint?

  1. static native int openCollator(String locale);
    static native int openCollator(String locale);

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

3.Editable类

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

[java] view plaincopyprint?

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

        /**
         * Returns the standard Editable Factory.
         */
        public static Editable.Factory getInstance() {
            return sInstance;
        }

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

4.AccessibilityManager类

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

[java] view plaincopyprint?

  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. }
    public static AccessibilityManager getInstance(Context context) {
        synchronized (sInstanceSync) {
            if (sInstance == null) {
                sInstance = new AccessibilityManager(context);
            }
        }
        return sInstance;
    }

这是单例模式C的应用。

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

[java] view plaincopyprint?

				


				
时间： 2024-10-13 01:00:38 

		


		


	

	
	

		


		
Android 设计模式 之 单例模式的相关文章


						

		

			

                Android设计模式之单例模式（Singleton Pattern）
			

		

		

									

				个人总结学习和研究,部分内容参考<Android源码设计模式解析与实战>一书~~ 一.  定义: 确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例. 也就是说,单例要满足3点: 1.单例类只能有一个实例. 2.单例类必须自己创建自己的唯一实例.(构造函数私有化,防止外部程序通过new来构造). 3.单例类必须给其他对象提供这一实例.(暴露公有静态方法或者通过枚举返回单例类对象). 二.  使用场景: 确保某个类有且只有一个对象的场景,避免产生多个对象消耗过多的资源.比如说在一个			

		

	

				

		

			

                Android设计模式之单例模式的七种写法
			

		

		

									

				一 单例模式介绍及它的使用场景 单例模式是应用最广的模式,也是我最先知道的一种设计模式.在深入了解单例模式之前.每当遇到如:getInstance()这样的创建实例的代码时,我都会把它当做一种单例模式的实现. 事实上常常使用的图片载入框架ImageLoader的实例创建就是使用了单例模式.由于这个ImageLoader中含有线程池.缓存系统.网络请求,非常消耗资源,不应该创建多个对象,这时候就须要用到单例模式. ImageLoader的创建代码例如以下: ImageLoader.getInsta			

		

	

						

		

			

                Android设计模式系列-单例模式
			

		

		

									

				单例模式,可以说是GOF的23种设计模式中最简单的一个. 这个模式相对于其他几个模式比较独立,它只负责控制自己的实例化数量单一(而不是考虑为用户产生什么样的实例),很有意思,是一个感觉上很干净的模式,本人很喜欢这个模式.android中很多地方都用到了单例模式,本文以输入法管理者InputMethodManager为例,展开分析.单例模式,Singleton Pattern,能够以其特有的优势,替代系统中全局变量,应用非常广泛. 1.意图保证一个类仅有一个实例,并提供一个访问它的全局访问点.热门			

		

	

				

		

			

                Android设计模式之单例模式
			

		

		

									

				定义 单例模式是一种常用的软件设计模式.在它的核心结构中只包含一个被称为单例的特殊类.通过单例模式可以保证系统中一个类只有一个实例 . 单例模式是设计模式中最简单的形式之一.这一模式的目的是使得类的一个对象成为系统中的唯一实例.要实现这一点,可以从客户端对其进行实例化开始.因此需 要用一种只允许生成对象类的唯一实例的机制,"阻止"所有想要生成对象的访问.使用工厂方法来限制实例化过程.这个方法应该是静态方法(类方法),因为让 类的实例去生成另一个唯一实例毫无意义. 其又分为三种形式 饿汉			

		

	

				

		

			

                Android 设计模式之单例模式
			

		

		

									

				设计模式是前人在开发过程中总结的一些经验,我们在开发过程中根据实际的情况,套用合适的设计模式,可以使程序结构更加简单,利于程序的扩展和维护,但也不是没有使用设计模式的程序就不好,如简单的程序就不用了,有种画蛇添足的感觉. 单例模式可以说是所有模式中最简单的一种,它自始至终只能创建一个实例,可以有两种形式,分别为懒汉式和饿汉式 一.饿汉式,很简单,一开始就创建了实例,实际上到底会不会被调用也不管 package com.dzt.singleton; /** * 饿汉式,线程安全 * * @auth			

		

	

				

		

			

                Android设计模式之单例模式 Singleton
			

		

		

									

				一.概述 单例模式是设计模式中最简单的一种,但是它没有设计模式中的那种各种对象之间的抽象关系,所以有人不认为它是一种模式,而是一种实现技巧.单例模式就像字面的意思一样,提供一个只能自己实例化的实例,并且提供了一个全局的访问点.要达到这几点要求就要满足三点:私有构造函数(防止被别人实例化),静态私有自身对象(用来提供实例),静态公有的getInstance方法(用来创建和获取实例对象). 优缺点: 单例只允许自己建立一个实例,不需要频繁创建和销毁,可以节省内存加快对象的访问速度. 但是单例没有抽象			

		

	

				

		

			

                java/android 设计模式学习笔记（一）---单例模式
			

		

		

									

				前段时间公司一些同事在讨论单例模式(我是最渣的一个,都插不上嘴 T__T ),这个模式使用的频率很高,也可能是很多人最熟悉的设计模式,当然单例模式也算是最简单的设计模式之一吧,简单归简单,但是在实际使用的时候也会有一些坑. PS:对技术感兴趣的同鞋加群544645972一起交流 设计模式总目录 java/android 设计模式学习笔记目录 特点 确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例. 单例模式的使用很广泛,比如:线程池(threadpool).缓存(cache).对			

		

	

				

		

			

                设计模式实例学习-单例模式（Android中的使用场景）
			

		

		

									

				1.设计模式实例-单例模式 单例模式,故名思议,是指在一个类中通过设置静态使得其仅创造一个唯一的实例.这样设置的目的是满足开发者的希望--这个类只需要被实例化创建一次,同时因为其为静态的缘故,加载的速度也应该快于正常实例化一个类的速度(理论上). 在Android开发中,当我们需要创建一个Fragment的时候常常会用到这样的模式,没有代码的学习是虚无的,接下来亮代码学习: public class SelectFrame extends Fragment { private final sta			

		

	

				

		

			

                Android 设计模式-单例模式
			

		

		

									

				Android 设计模式-单例模式 什么情况下需要单例模式? 一些类提供公共功能供别人调用,本身不会处理业务逻辑 类会被许多类和线程调用 设计单例模式 public class Singleton{ private static Singleton mSingleton; private Singleton(){ } public static Singleton getInstance(){ if(mSingleton == null){ mSingleton = new Singleton(