Android设计模式之单例模式

经常有人问我说Android学习如何进阶？不管你怎么走，设计模式可谓是进阶必备，对设计模式的理解与运用对你之后的代码书写与架构设计有很多的帮助作用，那么从今天开始我就抽时间来给大家分享下设计模式系列。

创新互联公司从2013年成立，公司自成立以来始终致力于为企业提供官网建设、移动互联网业务开发（微信平台小程序开发、手机网站建设、重庆APP软件开发等），并且包含互联网基础服务（域名、主机服务、企业邮箱、网络营销等）应用服务；以先进完善的建站体系及不断开拓创新的精神理念，帮助企业客户实现互联网业务，严格把控项目进度与质量监控加上过硬的技术实力获得客户的一致赞誉。

什么是设计模式？其实简单的理解就是前人留下来的一些经验总结而已，然后把这些经验起了个名字叫Design Pattern，翻译过来就是设计模式的意思，通过使用设计模式可以让我们的代码复用性更高，可维护性更高，让你的代码写的更优雅。设计模式理论上有23种，但是我只会针对Android平台上常用的一些设计模式做分享，今天就先来分享下最常用的单例模式。
饿汉式

 
 
 
    
  
  
  
  1. public class Singleton{ 
    2. 
  
  
  
  2. 
  
  
  
  3.     private static Singleton instance = new Singleton(); 
    4. 
  
  
  
  4. 
  
  
  
  5.     private Singleton(){} 
    6. 
  
  
  
  6. 
  
  
  
  7.     public static Singleton newInstance(){ 
    8. 
  
  
  
  8.         return instance; 
    9. 
  
  
  
  9.     } 
    10. 
  
  
  
  10. }
    11.

饿汉式是最简单的实现方式，这种实现方式适合那些在初始化时就要用到单例的情况，这种方式简单粗暴，如果单例对象初始化非常快，而且占用内存非常小的时候这种方式是比较合适的，可以直接在应用启动时加载并初始化。 但是，如果单例初始化的操作耗时比较长而应用对于启动速度又有要求，或者单例的占用内存比较大，再或者单例只是在某个特定场景的情况下才会被使用，而一般情况下是不会使用时，使用 饿汉式 的单例模式就是不合适的，这时候就需要用到 懒汉式 的方式去按需延迟加载单例。

懒汉式

 
 
 
    
  
  
  
  1. public class Singleton{ 
    2. 
  
  
  
  2.     private static Singleton instance = null; 
    3. 
  
  
  
  3. 
  
  
  
  4.     private Singleton(){} 
    5. 
  
  
  
  5. 
  
  
  
  6.     public static newInstance(){ 
    7. 
  
  
  
  7.         if(null == instance){ 
    8. 
  
  
  
  8.             instance = new Singleton(); 
    9. 
  
  
  
  9.         } 
    10. 
  
  
  
  10.         return instance; 
    11. 
  
  
  
  11.     } 
    12. 
  
  
  
  12. }
    13.

懒汉式与 饿汉式 的***区别就是将单例的初始化操作，延迟到需要的时候才进行，这样做在某些场合中有很大用处。比如某个单例用的次数不是很多，但是这个单例提供的功能又非常复杂，而且加载和初始化要消耗大量的资源，这个时候使用 懒汉式 就是非常不错的选择。
多线程下的单例模式

上面介绍了一些单例模式的基本应用方法，但是上面所说的那些使用方式都是有一个隐含的前提，那就是他们都是应用在单线程条件下，一旦换成了多线程就有出错的风险。

如果在多线程的情况下， 饿汉式 不会出现问题，因为JVM只会加载一次单例类，但是 懒汉式 可能就会出现重复创建单例对象的问题。为什么会有这样的问题呢？因为 懒汉式 在创建单例时是 线程不安全的，多个线程可能会并发调用他的 newInstance 方法导致多个线程可能会创建多份相同的单例出来。

那有没有办法，使 懒汉式 的单利模式也是线程安全的呢？答案肯定是有的，就是使用加同步锁的方式去实现。
懒汉式同步锁

 
 
 
    
  
  
  
  1. public class Singleton { 
    2. 
  
  
  
  2.   
    3. 
  
  
  
  3.     private static Singleton instance = null; 
    4. 
  
  
  
  4.   
    5. 
  
  
  
  5.     private Singleton(){ 
    6. 
  
  
  
  6.     } 
    7. 
  
  
  
  7.   
    8. 
  
  
  
  8.     public static Singleton getInstance() { 
    9. 
  
  
  
  9.         synchronized (Singleton.class) { 
    10. 
  
  
  
  10.             if (instance == null) { 
    11. 
  
  
  
  11.                 instance = new Singleton(); 
    12. 
  
  
  
  12.             } 
    13. 
  
  
  
  13.         } 
    14. 
  
  
  
  14.   
    15. 
  
  
  
  15.         return instance; 
    16. 
  
  
  
  16.     } 
    17. 
  
  
  
  17. }
    18.

这种是最常见的解决同步问题的一种方式，使用同步锁synchronized (Singleton.class)防止多线程同时进入造成instance被多次实例化。举个在Android使用这种方式的例子：
InputMethodManager示例

 
 
 
    
  
  
  
  1. public final class InputMethodManager { 
    2. 
  
  
  
  2.     //内部全局唯一实例   
    3. 
  
  
  
  3.     static InputMethodManager sInstance; 
    4. 
  
  
  
  4.     
    5. 
  
  
  
  5.     //对外api   
    6. 
  
  
  
  6.     public static InputMethodManager getInstance() { 
    7. 
  
  
  
  7.         synchronized (InputMethodManager.class) { 
    8. 
  
  
  
  8.             if (sInstance == null) { 
    9. 
  
  
  
  9.                 IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE); 
    10. 
  
  
  
  10.                 IInputMethodManager service = IInputMethodManager.Stub.asInterface(b); 
    11. 
  
  
  
  11.                 sInstance = new InputMethodManager(service, Looper.getMainLooper()); 
    12. 
  
  
  
  12.             } 
    13. 
  
  
  
  13.             return sInstance; 
    14. 
  
  
  
  14.         } 
    15. 
  
  
  
  15.     } 
    16. 
  
  
  
  16. }  
    17.

以上是Android源码中输入法类相关的单例使用方式。

但其实还有一种更好的方式如下：
双重校验锁

 
 
 
    
  
  
  
  1. 
  
  
  
  2. 
  
  
  
  3. public class Singleton { 
    4. 
  
  
  
  4.   
    5. 
  
  
  
  5.     private static volatile Singleton instance = null; 
    6. 
  
  
  
  6.   
    7. 
  
  
  
  7.     private Singleton(){ 
    8. 
  
  
  
  8.     } 
    9. 
  
  
  
  9.   
    10. 
  
  
  
  10.     public static Singleton getInstance() { 
    11. 
  
  
  
  11.         // if already inited, no need to get lock everytime 
    12. 
  
  
  
  12.         if (instance == null) { 
    13. 
  
  
  
  13.             synchronized (Singleton.class) { 
    14. 
  
  
  
  14.                 if (instance == null) { 
    15. 
  
  
  
  15.                     instance = new Singleton(); 
    16. 
  
  
  
  16.                 } 
    17. 
  
  
  
  17.             } 
    18. 
  
  
  
  18.         } 
    19. 
  
  
  
  19.   
    20. 
  
  
  
  20.         return instance; 
    21. 
  
  
  
  21.     } 
    22. 
  
  
  
  22. }
    23.

可以看到上面在synchronized (Singleton.class)外又添加了一层if，这是为了在instance已经实例化后下次进入不必执行synchronized (Singleton.class)获取对象锁，从而提高性能。

以上两种方式还是挺麻烦的，我们不禁要问，有没有更好的实现方式呢？答案是肯定的。 我们可以利用JVM的类加载机制去实现。在很多情况下JVM已经为我们提供了同步控制，比如：

在static{}区块中初始化的数据

访问final字段时

等等

因为在JVM进行类加载的时候他会保证数据是同步的，我们可以这样实现：

采用内部类，在这个内部类里面去创建对象实例。这样的话，只要应用中不使用内部类 JVM 就不会去加载这个单例类，也就不会创建单例对象，从而实现 懒汉式 的延迟加载和线程安全。

实现代码如下：
静态内部类

 
 
 
    
  
  
  
  1. 
  
  
  
  2. 
  
  
  
  3. public class Singleton{ 
    4. 
  
  
  
  4.     //内部类，在装载该内部类时才会去创建单利对象 
    5. 
  
  
  
  5.     private static class SingletonHolder{ 
    6. 
  
  
  
  6.         public static Singleton instance = new Singleton(); 
    7. 
  
  
  
  7.     } 
    8. 
  
  
  
  8. 
  
  
  
  9.     private Singleton(){} 
    10. 
  
  
  
  10. 
  
  
  
  11.     public static Singleton newInstance(){ 
    12. 
  
  
  
  12.         return SingletonHolder.instance; 
    13. 
  
  
  
  13.     } 
    14. 
  
  
  
  14. 
  
  
  
  15.     public void doSomething(){ 
    16. 
  
  
  
  16.         //do something 
    17. 
  
  
  
  17.     } 
    18. 
  
  
  
  18. }
    19.

这样实现出来的单例类就是线程安全的，而且使用起来很简洁，麻麻再也不用担心我的单例不是单例了。

然而这还不是最简单的方式， Effective Java 中推荐了一种更简洁方便的使用方式，就是使用枚举。
枚举类型单例模式

 
 
 
    
  
  
  
  1. public enum Singleton{ 
    2. 
  
  
  
  2.     //定义一个枚举的元素，它就是Singleton的一个实例 
    3. 
  
  
  
  3.     instance; 
    4. 
  
  
  
  4. 
  
  
  
  5.     public void doSomething(){ 
    6. 
  
  
  
  6.         // do something ... 
    7. 
  
  
  
  7.     }     
    8. 
  
  
  
  8. }
    9.

使用方法如下：

 
 
 
    
  
  
  
  1. public static void main(String[] args){ 
    2. 
  
  
  
  2.    Singleton singleton = Singleton.instance; 
    3. 
  
  
  
  3.    singleton.doSomething(); 
    4. 
  
  
  
  4. }
    5.

默认枚举实例的创建是线程安全的.(创建枚举类的单例在JVM层面也是能保证线程安全的), 所以不需要担心线程安全的问题，所以理论上枚举类来实现单例模式是最简单的方式。
总结

一般单例模式包含了5种写法，分别是饿汉、懒汉、双重校验锁、静态内部类和枚举。相信看完之后你对单例模式有了充分的理解了，根据不同的场景选择最你最喜欢的一种单例模式吧！

新闻标题：Android设计模式之单例模式
文章起源：http://www.shufengxianlan.com/qtweb/news42/543942.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

移动网站建设知识

各行业网站

成都电信服务器托管　　 　泸州叙永网站建设　　 　成都酒店服定制　　 　上市集团网站建设　　 　成都服务器托管　　 　成都手机网站建设　　 　成都微商城开发　　 　手机网站建设　　 　成都网站优化　　 　成都铁科精智测控　　 　分类目录网站　　 　重庆网站建设　　 　绵阳电信机房　　 　云主机　　 　雅安移动机房　　 　手机微信网站　　 　简阳网站建设　　 　航龙航空　　 　网站设计制作报价　　 　wap手机网站