android单例模式详解,Android设计模式之单例模式的七种写法

一 单例模式介绍及它的使用场景

单例模式是应用最广的模式，也是我最早知道的一种设计模式，在深刻了解单例模式以前，每当遇到如：getInstance()这样的建立实例的代码时，我都会把它当作一种单例模式的实现。其实常用的图片加载框架ImageLoader的实例建立就是使用了单例模式，由于这个ImageLoader中含有线程池、缓存系统、网络请求，很消耗资源，不该该建立多个对象，这时候就须要用到单例模式。java

ImageLoader的建立代码以下：web

ImageLoader.getInstance();// 在本身的Application中建立全局实例

.....

//getInstance()执行的源码

public static ImageLoader getInstance() {

if(instance == null) {//双重校验DCL单例模式

Class var0 = ImageLoader.class;

synchronized(ImageLoader.class) {//同步代码块

if(instance == null) {

instance = new ImageLoader();//建立一个新的实例

}

}

}

return instance;//返回一个实例

}

所以，在咱们建立一个对象须要消耗过多的资源时，即可以考虑使用单例模式。设计模式

二 单例模式的结构图以及建立的关键点？

单例模式的定义是它应该保证一个类仅有一个实例，同时这个类还必须提供一个访问该类的全局访问点。以下图是单例模式的结构图：缓存

实现单例模式有如下几个关键点：

(1)其构造函数不对外开放，通常为private；

(2)经过一个静态方法或者枚举返回单例类对象；

(3)确保单例类的对象有且只有一个，尤为要注意多线程的场景；

(4)确保单例类对象在反序列化时不会从新建立对象；安全

经过将单例类的构造函数私有化，使得客户端不能经过new的形式手动构造单例类的对象。单例类会主动暴露一个公有的静态方法，客户端调用这个静态的方法获取到单例类的惟一实例。在获取这个单例类的时候须要确保这个过程是线程安全的。网络

三 单例模式的七种实现方式

(1)懒汉式(线程不安全)

//懒汉式单例类.在第一次调用的时候实例化本身

public class Singleton {

//私有的构造函数

private Singleton() {}

//私有的静态变量

private static Singleton single=null;

//暴露的公有静态方法

public static Singleton getInstance() {

if (single == null) {

single = new Singleton();

}

return single;

}

}

懒汉式(线程不安全)的单例模式分为三个部分：私有的构造方法，私有的全局静态变量，公有的静态方法。多线程

其中起到重要做用的是静态修饰符static关键字，咱们知道在程序中，任何变量或者代码都是在编译时由系统自动分配内存来存储的，而所谓静态就是指在编译后所分配的内存会一直存在，直到程序退出内存才会释放这个空间，所以也就保证了单例类的实例一旦建立，便不会被系统回收，除非手动设置为null。并发

这种方式建立的缺点是存在线程不安全的问题，解决的办法就是使用synchronized 关键字，即是单例模式的第二种写法了。框架

(2)懒汉式(线程安全)

public class Singleton {

//私有的静态变量

private static Singleton instance;

//私有的构造方法

private Singleton (){}；

//公有的同步静态方法

public static synchronized Singleton getInstance() {

if (instance == null) {

instance = new Singleton();

}

return instance;

}

}

这种单例实现方式的getInstance()方法中添加了synchronized 关键字，也就是告诉Java(JVM)getInstance是一个同步方法。svg

同步的意思是当两个并发线程访问同一个类中的这个synchronized同步方法时， 一个时间内只能有一个线程获得执行，另外一个线程必须等待当前线程执行完才能执行，所以同步方法使得线程安全，保证了单例只有惟一个实例。

可是它的缺点在于每次调用getInstance()都进行同步，形成了没必要要的同步开销。这种模式通常不建议使用。

(3)饿汉模式(线程安全)

代码实现以下：

//饿汉式单例类.在类初始化时，已经自行实例化

public class Singleton {

//static修饰的静态变量在内存中一旦建立，便永久存在

private static Singleton instance = new Singleton();

private Singleton (){}

public static Singleton getInstance() {

return instance;

}

}

饿汉式在类建立的同时就已经建立好一个静态的对象供系统使用，之后再也不改变，因此天生是线程安全的。其中instance=new Singleton()能够写成：

static {

instance = new Singleton();

}

属于变种的饿汉单例模式，也是基于classloder机制避免了多线程的同步问题，instance在类装载时就实例化了。

(4)DCL双重校验模式

public class Singleton {

private static Singleton singleton; //静态变量

private Singleton (){} //私有构造函数

public static Singleton getInstance() {

if (singleton == null) { //第一层校验

synchronized (Singleton.class) {

if (singleton == null) { //第二层校验

singleton = new Singleton();

}

}

}

return singleton;

}

}

这种模式的亮点在于getInstance()方法上，其中对singleton 进行了两次判断是否空，第一层判断是为了不没必要要的同步，第二层的判断是为了在null的状况下才建立实例。具体咱们来分析一下：

假设线程A执行到了singleton = new Singleton(); 语句，这里看起来是一句代码，可是它并非一个原子操做，这句代码最终会被编译成多条汇编指令，它大体会作三件事情：

(a)给Singleton的实例分配内存

(b)调用Singleton()的构造函数，初始化成员字段；

(c)将singleton对象指向分配的内存空间(即singleton不为空了)；

可是因为Java编译器容许处理器乱序执行，以及在jdk1.5以前，JMM(Java Memory Model：java内存模型)中Cache、寄存器、到主内存的回写顺序规定，上面的步骤b 步骤c的执行顺序是不保证了。也就是说执行顺序多是a-b-c，也多是a-c-b,若是是后者的指向顺序，而且偏偏在c执行完毕，b还没有执行时，被切换到线程B中，这时候由于singleton在线程A中执行了步骤c了，已经非空了，因此，线程B直接就取走了singleton，再使用时就会出错。这就是DCL失效问题。

可是在JDK1.5以后，官方给出了volatile关键字，将singleton定义的代码改为：

private volatile static Singleton singleton; //使用volatile 关键字

这样就解决了DCL失效的问题。

(5)静态内部类单例模式

public class Singleton {

private Singleton (){} ;//私有的构造函数

public static final Singleton getInstance() {

return SingletonHolder.INSTANCE;

}

//定义的静态内部类

private static class SingletonHolder {

private static final Singleton INSTANCE = new Singleton(); //建立实例的地方

}

}

当第一次加载Singleton 类的时候并不会初始化INSTANCE ，只有第一次调用Singleton 的getInstance()方法时才会致使INSTANCE 被初始化。所以，第一次调用getInstance()方法会致使虚拟机加载SingletonHolder 类，这种方式不只可以确保单例对象的惟一性，同时也延迟了单例的实例化。

(6)枚举单例

前面的几种单例模式实现方式，通常都会稍显麻烦，或是在某些特定的状况下出现一些情况。下面介绍枚举单例模式的实现：

public enum Singleton { //enum枚举类

INSTANCE;

public void whateverMethod() {

}

}

枚举单例模式最大的优势就是写法简单，枚举在java中与普通的类是同样的，不只可以有字段，还可以有本身的方法，最重要的是默认枚举实例是线程安全的，而且在任何状况下，它都是一个单例。即便是在反序列化的过程，枚举单例也不会从新生成新的实例。而其余几种方式，必须加入以下方法：

private Object readResolve() throws ObjectStreamException{

return INSTANCE;

}

才能保证反序列化时不会生成新的对象。

(7)使用容器实现单例模式

除了上述几种常见的实现单例的方式，还有另外一类的实现，代码以下：

public class SingletonManager {

private static Map objMap = new HashMap();//使用HashMap做为缓存容器

private Singleton() {

}

public static void registerService(String key, Objectinstance) {

if (!objMap.containsKey(key) ) {

objMap.put(key, instance) ;//第一次是存入Map

}

}

public static ObjectgetService(String key) {

return objMap.get(key) ;//返回与key相对应的对象

}

}

在程序的初始，将多种单例模式注入到一个统一的管理类中，在使用时根据key获取对应类型的对象。

在Android源码中，APP启动的时候，虚拟机第一次加载该类时会注册各类ServiceFetcher，好比LayoutInflater Service。将这些服务以键值对的形式存储在一个HashMap中，用户使用时只须要根据key来获取到对应的ServiceFetcher，而后经过ServiceFetcher对象的getService函数获取具体的服务对象。当第一次获取时，会调用ServiceFetcher的creatService函数建立服务对象，而后将该对象缓存到一个列表中，下次再取时直接从缓存中获取，避免重复建立对象，从而达到单例的效果。Android中的系统核心服务以单例形式存在，减小了资源消耗。

总结：无论以哪一种形式实现单例模式，它们的核心原理是将构造函数私有化，而且经过静态公有方法获取一个惟一的实例，在这个获取的过程当中必须保证线程的安全，同时也要防止反序列化致使从新生成实例对象。