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：

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：

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：

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:

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:

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:

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

单例代码：

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

单例代码：

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);
    }
    

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

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

1. static native int openCollator(String locale);

    static native int openCollator(String locale);

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

3.Editable类

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

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

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在不同地方使用了不同的单例模式实现方式。