一直想整理一下关于andorid设计模式的文章，也方便自己需要的时候回顾下，由于有些地方也没弄明白，所以有些地方可能理解的不对，对于这些欢迎大家指出，共同讨论一起进步，@—@ 哈哈！
单例模式：
单例模式应该是设计模式中最容易理解，也是最容易手写代码的，大家平时写代码中也应该经常使用到，那究竟什么是单例了? 我的理解就是在一个类中只实例化一个实例，并向整个系统提供一个节点使用该个实例。那什么时候应该去使用单例模式了？通常来说只有是在该类需要进行大量耗资源操作或者只需要创建一个实例的情况下使用，例如一个班级只有一个班长，一个国家只有一个主席等等。而在android系统中也有很多地方用到单例模式，我们经常会通过Context获取系统级别的服务，比如WindowsManagerService， ActivityManagerService等,更常用的是一个叫LayoutInflater的类, 这些类以单例的形式注册在系统中，我们需要的时候就通过Context的getSystemService(String key)获取。
既然说了什么是单例，那如何使用了？单例的写法在java中有很多，接下来回列举一些常用的写法。
１.懒汉式（就是在需要调用时候去加载）
public class SingleInstance {
private static SingleInstance mInstance;
/**
* 创建私有构造器
*/
private SingleInstance() {
}
public static SingleInstance getInstance() {
if (mInstance == null) {
mInstance = new SingleInstance();
}
return mInstance;
}}
这个应该是最常见的一种写法，很多书上视频上都是这样写的，但是这种写法在多线程的情况下会实例化多个实例，因此这个是线程不安全的。所以为了保证线程安全可以加上关键字synchronized
public class SingleInstance {
private static SingleInstance mInstance;
/**
* 创建私有构造器
*/
private SingleInstance() {
}
public static synchronized SingleInstance getInstance() {
if (mInstance == null) {
mInstance = new SingleInstance();
}
return mInstance;
}}
加上synchronized的关键字可以解决实例化多个实例的问题，但方法前加这个效率并不高，每次只能用一个线程访问，所以可以在上面的基础上这样修改。
2.双重检验锁模式
public class SingleInstance {
private static SingleInstance mInstance;
/**
* 创建私有构造器
*/
private SingleInstance() {
}
public static SingleInstance getInstance() {
if (mInstance == null) {
synchronized (SingleInstance.class) {
if(mInstance == null){
mInstance = new SingleInstance();
}
}
}
return mInstance;
}}
这种写法就是双重检验锁模式，进行两次检验mInstance的操作，一次是同步前，一次是同步后，防止多次实例化。但是这种方式任然存在问题的可能，它是有问题，主要在于mInstance= new SingleInstance()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。
１.给 mInstance分配内存
２.调用 SingleInstance的构造函数来初始化成员变量
３.将mInstance对象指向分配的内存空间.
但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 mInstance已经是非 null 了（但却没有初始化），所以线程二会直接返回 mInstance,此时就会出错了。那对于上面这个问题我们只需要将 mInstance变量声明成 volatile 就可以了。java 1.5后对其进行了修改，当引入volatile时 具备以下几点：
1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
2）禁止进行指令重排序。
volatile关键字禁止指令重排序有两层意思：
1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；
2）在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。
这样就不会存在无序写入，那么SingleInstace对象不会存在返回一个没有实例话的对象，只有实话成功后才会将该地址指向对象。
具体vollatile可以参见这篇文章：Volatile。
3.饿汉式 static final field
这种方式是直接在类加载到内存时去初始化的，同时声明为final和static所以创建实例本身是线程安全的。
public class SingleInstance {
//类加载时就初始化
private static final SingleInstance mInstance= new SingleInstance ();
private SingleInstance (){}
public static SingleInstance getInstance(){
return mInstance;
}}
4.静态内部类 static nested class
public class SingleInstance {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private SingleInstance (){}
public final static SingleInstance getInstance(){
return mInstance;
}}
因为同样修饰了final，static ，同时SingletonHolder是静态内部类，只有getInstance调用时才会加载，所以也是惰性初始化（懒加载）。
5.最后一种用的很少的枚举
用枚举写单例实在太简单了！这也是它最大的优点。下面这段代码就是声明枚举实例的通常做法。
public enum SingleInstance {
//枚举元素
INSTANCE;}
而枚举单例应该是代码最简单的实现方式了，同时一般单例存在的另外一个问题是一旦你实现了序列化接口，那么它们不再保持单例了，因为readObject()方法一直返回一个新的对象就，而枚举你可以通过使用readResolve()方法来避免。
public enum SingleInstance {
//枚举元素
private Object readResolve(){
return INSTANCE;
}
}
这些就是常用的单例实现方式，那么是不是保证单例的安全性和效率是不是就不会有问题了，不是由于单例模式对象是静态的所以其生命周期比较长，容易造成内存泄漏。特别是传递Context 对象时特别注意：
public class SingleInstance {
private static SingleInstance mInstance;
private Context mcContext;
/**
* 创建私有构造器
*/
private SingleInstance(Context c) {
mcContext = c;
}
public static SingleInstance getInstance(Context c) {
if (mInstance == null) {
synchronized (SingleInstance.class) {
if (mInstance == null) {
mInstance = new SingleInstance(c);
}
}
}
return mInstance;
}}
如果传递的是一个activity的句柄时，如果该activity退出，系统GC的时候试图去回收，但它的句柄被该单例对象引用，GC回收它失败，就会造成内存泄漏。所以单例的时候如果引入Context对象时，最好用弱引用或者private WeakReference<Context> c，或者是调用ApplicationContext对象其生命周期伴随整个应用。关于单例一般都是以上所说，如果大家有更多的了解欢迎补充。总的来说单例在某些情况下可控制实例产生的数量，达到节约资源的目的，同时也可进行数据媒介共享，它可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程之间实现通信。但单例不足之处就是单利模式中没有抽象层，因此单例类的扩展有很大的困难。
