优优下载-手机电脑软件免费下载基地

最新更新 | 排行榜单 | 软件发布 |
网站导航

软件下载

网络软件 聊天工具 应用软件 安全相关 图像软件 驱动程序 系统工具 媒体工具 其他软件

安卓专区

安卓应用 安卓游戏

苹果专区

苹果应用 苹果游戏

优优资讯

优优资讯

专题库

专题库

热搜： 抖音 剪映 百度贴吧 网易云音乐 微博

首页 安卓专区 苹果专区 软件下载 优优资讯 专题库
当前位置:首页>优优资讯 > 软件教程 > 电脑软件教程 > 谈谈Android Java语言中单例这种设计模式

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

作者:本站整理 时间:2015-08-03

 
谈谈Android Java语言中单例这种设计模式
 
　　随着我们编写代码的深入，我们或多或少都会接触到设计模式，其中单例(Singleton)模式应该是我们耳熟能详的一种模式。本文将比较特别的介绍一下Java设计模式中的单例模式。
 
　　概念
 
　　单例模式，又称单件模式或者单子模式，指的是一个类只有一个实例，并且提供一个全局访问点。
 
　　实现思路
 
　　在单例的类中设置一个private静态变量sInstance，sInstance类型为当前类，用来持有单例唯一的实例。
 
　　将（无参数）构造器设置为private，避免外部使用new构造多个实例。
 
　　提供一个public的静态方法，如getInstance，用来返回该类的唯一实例sInstance。
 
　　其中上面的单例的实例可以有以下几种创建形式，每一种实现都需要保证实例的唯一性。
 
　　饿汉式
 
　　饿汉式指的是单例的实例在类装载时进行创建。如果单例类的构造方法中没有包含过多的操作处理，饿汉式其实是可以接受的。
 
　　饿汉式的常见代码如下,当SingleInstance类加载时会执行
 
　　private static SingleInstance sInstance = new SingleInstance();
 
　　初始化了唯一的实例，然后getInstance()直接返回sInstance即可。
 
　　public class SingleInstance {
　　private static SingleInstance sInstance = new SingleInstance();
　　private SingleInstance() {
　　}
　　public static SingleInstance getInstance() {
　　return sInstance;
　　}
　　}
 
　　饿汉式的问题
 
　　如果构造方法中存在过多的处理，会导致加载这个类时比较慢，可能引起性能问题。
 
　　如果使用饿汉式的话，只进行了类的装载，并没有实质的调用，会造成资源的浪费。
 
　　懒汉式
 
　　懒汉式指的是单例实例在第一次使用时进行创建。这种情况下避免了上面饿汉式可能遇到的问题。
 
　　但是考虑到多线程的并发操作，我们不能简简单单得像下面代码实现。
 
　　public class SingleInstance {
　　private static SingleInstance sInstance;
　　private SingleInstance() {
　　}
　　public static SingleInstance getInstance() {
　　if (null == sInstance) {
　　sInstance = new SingleInstance();
　　}
　　return sInstance;
　　}
　　}
 
　　上述的代码在多个线程密集调用getInstance时，存在创建多个实例的可能。比如线程A进入null == sInstance这段代码块，而在A线程未创建完成实例时，如果线程B也进入了该代码块，必然会造成两个实例的产生。
 
　　synchronized修饰方法
 
　　使用synchrnozed修饰getInstance方法可能是最简单的一个保证多线程保证单例唯一性的方法。
 
　　synchronized修饰的方法后，当某个线程进入调用这个方法，该线程只有当其他线程离开当前方法后才会进入该方法。所以可以保证getInstance在任何时候只有一个线程进入。
 
　　public class SingleInstance {
　　private static SingleInstance sInstance;
　　private SingleInstance() {
　　}
　　public static synchronized SingleInstance getInstance() {
　　if (null == sInstance) {
　　sInstance = new SingleInstance();
　　}
　　return sInstance;
　　}
　　}
 
　　但是使用synchronized修饰getInstance方法后必然会导致性能下降，而且getInstance是一个被频繁调用的方法。虽然这种方法能解决问题，但是不推荐。
 
　　双重检查加锁
 
　　使用双重检查加锁，首先进入该方法时进行null == sInstance检查，如果第一次检查通过，即没有实例创建，则进入synchronized控制的同步块,并再次检查实例是否创建，如果仍未创建，则创建该实例。
 
　　双重检查加锁保证了多线程下只创建一个实例，并且加锁代码块只在实例创建的之前进行同步。如果实例已经创建后，进入该方法，则不会执行到同步块的代码。
 
　　public class SingleInstance {
　　private static volatile SingleInstance sInstance;
　　private SingleInstance() {
　　}
　　public static SingleInstance getInstance() {
　　if (null == sInstance) {
　　synchronized (SingleInstance.class) {
　　if (null == sInstance) {
　　sInstance = new SingleInstance();
　　}
　　}
　　}
　　return sInstance;
　　}
　　}
 
　　volatile是什么
 
　　Volatile是轻量级的synchronized，它在多处理器开发中保证了共享变量的“可见性”。可见性的意思是当一个线程修改一个共享变量 时，另外一个线程能读到这个修改的值。使用volatile修饰sInstance变量之后，可以确保多个线程之间正确处理sInstance变量。
 
　　关于volatile，可以访问深入分析Volatile的实现原理了解更多。
 
　　利用static机制
 
　　在Java中，类的静态初始化会在类被加载时触发，我们利用这个原理，可以实现利用这一特性，结合内部类，可以实现如下的代码，进行懒汉式创建实例。
 
　　public class SingleInstance {
　　private SingleInstance() {
　　}
　　public static SingleInstance getInstance() {
　　return SingleInstanceHolder.sInstance;
　　}
　　private static class SingleInstanceHolder {
　　private static SingleInstance sInstance = new SingleInstance();
　　}
　　}
 
　　关于这种机制，可以具体了解双重检查锁定与延迟初始化
 
　　好奇问题
 
　　真的只有一个对象么
 
　　其实，单例模式并不能保证实例的唯一性，只要我们想办法的话，还是可以打破这种唯一性的。以下几种方法都能实现。
 
　　- 使用反射，虽然构造器为非公开，但是在反射面前就不起作用了。
　　- 如果单例的类实现了cloneable，那么还是可以拷贝出多个实例的。
　　- Java中的对象序列化也有可能导致创建多个实例。避免使用readObject方法。
　　- 使用多个类加载器加载单例类，也会导致创建多个实例并存的问题。
 
　　单例可以继承么
 
　　单例类能否被继承需要分情况而定。
 
　　可以继承的情况
 
　　当子类是父类单例类的内部类时，继承是可以的。
 
　　public class BaseSingleton {
　　private static volatile BaseSingleton sInstance;
　　private BaseSingleton() {
　　}
　　public static BaseSingleton getInstance() {
　　if (null == sInstance) {
　　synchronized(BaseSingleton.class) {
　　if (null == sInstance) {
　　sInstance = new BaseSingleton();
　　}
　　}
　　}
　　return sInstance;
　　}
　　public static class  MySingleton extends BaseSingleton {
　　}
　　}
 
　　但是上面仅仅是编译和执行上允许的，但是继承单例没有实际的意义，反而会变得更加事倍功半，其代价要大于新写一个单例类。感兴趣的童鞋可以尝试折腾一下。
 
　　不可以继承的情况
 
　　如果子类为单独的类，非单例类的内部类的话，那么在编译时就会出错Implicit super constructor BaseSingleton() is not visible for default constructor. Must define an explicit constructor，主要原因是单例类的构造器是private，解决方法是讲构造器设置为可见，但是这样做就无法保证单例的唯一性。所以这种方式不可以继承。
 
　　总的来说，单例类不要继承。
 
　　单例 vs static变量
 
　　全局静态变量也可以实现单例的效果，但是使用全局变量无法保证只创建一个实例，而且使用全局变量的形式，需要团队的约束，执行起来可能会出现问题。
 
　　关于GC
 
　　因为单例类中又一个静态的变量持有单例的实例，所以相比普通的对象，单例的对象更不容易被GC回收掉。单例对象的回收应该发生在其类加载器被GC回收掉之后，一般不容易出现。
 
标签 Android开发 Java语言 设计模式

相关文章

相关推荐

最新攻略

用户评论

（已有0条评论）
表情
注：您的评论需要经过审核才能显示哦，请文明发言！
还没有评论，快来抢沙发吧！
快速检索 0-9 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z