谈谈Android Java语言中单例这种设计模式

随着我们编写代码的深入，我们或多或少都会接触到设计模式，其中单例(Singleton)模式应该是我们耳熟能详的一种模式。本文将比较特别的介绍一下Java设计模式中的单例模式。

10年积累的成都网站设计、成都网站制作、外贸网站建设经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先制作网站后付款的网站建设流程，更有涞水免费网站建设让你可以放心的选择与我们合作。

概念

单例模式，又称单件模式或者单子模式，指的是一个类只有一个实例，并且提供一个全局访问点。

实现思路

  • 在单例的类中设置一个private静态变量sInstance，sInstance类型为当前类，用来持有单例***的实例。
  • 将（无参数）构造器设置为private，避免外部使用new构造多个实例。
  • 提供一个public的静态方法，如getInstance，用来返回该类的***实例sInstance。

其中上面的单例的实例可以有以下几种创建形式，每一种实现都需要保证实例的***性。

饿汉式

饿汉式指的是单例的实例在类装载时进行创建。如果单例类的构造方法中没有包含过多的操作处理，饿汉式其实是可以接受的。

饿汉式的常见代码如下,当SingleInstance类加载时会执行

 
 
 
      
  
  
  1. private static SingleInstance sInstance = new SingleInstance(); 
    2.

初始化了***的实例，然后getInstance()直接返回sInstance即可。

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

饿汉式的问题

  • 如果构造方法中存在过多的处理，会导致加载这个类时比较慢，可能引起性能问题。
  • 如果使用饿汉式的话，只进行了类的装载，并没有实质的调用，会造成资源的浪费。

懒汉式

懒汉式指的是单例实例在***次使用时进行创建。这种情况下避免了上面饿汉式可能遇到的问题。

但是考虑到多线程的并发操作，我们不能简简单单得像下面代码实现。

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

上述的代码在多个线程密集调用getInstance时，存在创建多个实例的可能。比如线程A进入null == sInstance这段代码块，而在A线程未创建完成实例时，如果线程B也进入了该代码块，必然会造成两个实例的产生。

synchronized修饰方法

使用synchrnozed修饰getInstance方法可能是最简单的一个保证多线程保证单例***性的方法。
synchronized修饰的方法后，当某个线程进入调用这个方法，该线程只有当其他线程离开当前方法后才会进入该方法。所以可以保证getInstance在任何时候只有一个线程进入。

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

但是使用synchronized修饰getInstance方法后必然会导致性能下降，而且getInstance是一个被频繁调用的方法。虽然这种方法能解决问题，但是不推荐。

双重检查加锁

使用双重检查加锁，首先进入该方法时进行null == sInstance检查，如果***次检查通过，即没有实例创建，则进入synchronized控制的同步块,并再次检查实例是否创建，如果仍未创建，则创建该实例。

双重检查加锁保证了多线程下只创建一个实例，并且加锁代码块只在实例创建的之前进行同步。如果实例已经创建后，进入该方法，则不会执行到同步块的代码。

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

volatile是什么

Volatile是轻量级的synchronized，它在多处理器开发中保证了共享变量的“可见性”。可见性的意思是当一个线程修改一个共享变量 时，另外一个线程能读到这个修改的值。使用volatile修饰sInstance变量之后，可以确保多个线程之间正确处理sInstance变量。
关于volatile，可以访问深入分析Volatile的实现原理了解更多。

利用static机制

在Java中，类的静态初始化会在类被加载时触发，我们利用这个原理，可以实现利用这一特性，结合内部类，可以实现如下的代码，进行懒汉式创建实例。

 
 
 
      
  
  
  1. public class SingleInstance { 
    2.   
  
  
  2.   private SingleInstance() { 
    3.   
  
  
  3.   } 
    4.   
  
  
  4.    
    5.   
  
  
  5.   public static SingleInstance getInstance() { 
    6.   
  
  
  6.       return SingleInstanceHolder.sInstance; 
    7.   
  
  
  7.   } 
    8.   
  
  
  8.    
    9.   
  
  
  9.   private static class SingleInstanceHolder { 
    10.   
  
  
  10.       private static SingleInstance sInstance = new SingleInstance(); 
    11.   
  
  
  11.   } 
    12.   
  
  
  12. } 
    13.

关于这种机制，可以具体了解双重检查锁定与延迟初始化

好奇问题

真的只有一个对象么

其实，单例模式并不能保证实例的***性，只要我们想办法的话，还是可以打破这种***性的。以下几种方法都能实现。

  • 使用反射，虽然构造器为非公开，但是在反射面前就不起作用了。
  • 如果单例的类实现了cloneable，那么还是可以拷贝出多个实例的。
  • Java中的对象序列化也有可能导致创建多个实例。避免使用readObject方法。
  • 使用多个类加载器加载单例类，也会导致创建多个实例并存的问题。

单例可以继承么

单例类能否被继承需要分情况而定。

可以继承的情况

当子类是父类单例类的内部类时，继承是可以的。

 
 
 
      
  
  
  1. public class BaseSingleton { 
    2.   
  
  
  2.   private static volatile BaseSingleton sInstance; 
    3.   
  
  
  3.    
    4.   
  
  
  4.   private BaseSingleton() { 
    5.   
  
  
  5.        
    6.   
  
  
  6.   } 
    7.   
  
  
  7.    
    8.   
  
  
  8.   public static BaseSingleton getInstance() { 
    9.   
  
  
  9.       if (null == sInstance) { 
    10.   
  
  
  10.           synchronized(BaseSingleton.class) { 
    11.   
  
  
  11.               if (null == sInstance) { 
    12.   
  
  
  12.                   sInstance = new BaseSingleton(); 
    13.   
  
  
  13.               } 
    14.   
  
  
  14.           } 
    15.   
  
  
  15.       } 
    16.   
  
  
  16.       return sInstance; 
    17.   
  
  
  17.   } 
    18.   
  
  
  18.    
    19.   
  
  
  19.   public static class  MySingleton extends BaseSingleton { 
    20.   
  
  
  20.        
    21.   
  
  
  21.   } 
    22.   
  
  
  22.    
    23.   
  
  
  23. } 
    24.

但是上面仅仅是编译和执行上允许的，但是继承单例没有实际的意义，反而会变得更加事倍功半，其代价要大于新写一个单例类。感兴趣的童鞋可以尝试折腾一下。

不可以继承的情况

如果子类为单独的类，非单例类的内部类的话，那么在编译时就会出错Implicit super constructor BaseSingleton() is not visible for default constructor. Must define an explicit constructor，主要原因是单例类的构造器是private，解决方法是讲构造器设置为可见，但是这样做就无法保证单例的***性。所以这种方式不可以继承。

总的来说，单例类不要继承。

单例 vs static变量

全局静态变量也可以实现单例的效果，但是使用全局变量无法保证只创建一个实例，而且使用全局变量的形式，需要团队的约束，执行起来可能会出现问题。

关于GC

因为单例类中又一个静态的变量持有单例的实例，所以相比普通的对象，单例的对象更不容易被GC回收掉。单例对象的回收应该发生在其类加载器被GC回收掉之后，一般不容易出现。

网站题目：谈谈Android Java语言中单例这种设计模式
分享链接：http://www.shufengxianlan.com/qtweb/news26/481626.html

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

广告

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

猜你还喜欢下面的内容

营销型网站建设知识

同城分类信息

B2C电商系统　　 　和正兴机械　　 　广安网站设计　　 　域名注册　　 　成都主机托管　　 　犀浦封阳台　　 　娄底尾呼妄服装　　 　成都网站安全运维　　 　小谭网创广告　　 　软文发布平台　　 　达州网站制作　　 　成都app软件开发　　 　手机网站制作　　 　网站制作　　 　广汉网站建设　　 　成都网站建设公司　　 　蓬溪网站建设　　 　乐山企业网站设计　　 　犀浦防护栏定制　　 　成都网站排名