android设计模式之单例模式

（其实设计模式应该从属于java，但是会专门针对android做相应的解释，所以就取名为android设计模式~）

一.单例模式的介绍

单例模式是应用最广的模式之一，在应用这个模式的时候，单例对象的类必须保证只有一个实例存在。在android中的应用场景例如整个app只有一个application对象，只有一个ImageLoader对象等。

二.单例模式下的各种实现方式

1.饿汉模式

public class Singleton {  
   private Singleton() {}  //在该类初始化的时候就会自行实例化                           
   private static final Singleton single = new Singleton();   
   public static Singleton getInstance() {  
      return single;  
   } 
} 

2.懒汉模式

public class Singleton { 
    private Singleton(){} 
    private final static Singleton mInstance; //没有care线程安全的问题 
    public static Singleton getInstance() { 
        if(mInstance == null){ 
            mInstance = new Singleton(); 
        } 
        return mInstance; 
    }
}

Tips:不论是饿汉模式还是懒汉模式，可能在你的app中都占有一席之地。那么我们先来对比下两者的区别，首先饿汉模式会在该类初始化的时候就自动实例化，而懒汉模式则会在对应调用getInstance方法时才会对应的实例化，实现了实例的延时加载。设想如果该实例在app中不一定被使用到，那么使用懒汉模式就可以节省内存。但是懒汉模式会在第一次获取实例时较为耗时，饿汉模式由于在初始化类时就进行了实例化，第一次获取实例就不会耗时。

以上是针对饿汉模式和懒汉模式之间的区别做的分析，接下来我们来关注之前代码中对于懒汉模式线程不安全的问题。分别提供以下几种解决方案来进行对比：

2.1.在getInstance方法上加同步锁

public class Singleton { 
     private Singleton(){} 
     private final static Singleton mInstance; //加上同步锁 
     public static synchronized Singleton getInstance() { 
        if(mInstance == null){ 
             mInstance = new Singleton(); 
        } 
        return mInstance; 
     }
}

这种方法虽然解决了线程安全的问题，但是单例模式一般都是应用在一些会被频繁调用的场景上的，如果在每次获取实例的时候都需要去进行线程同步，那会增加不小的开销，会使单例的获取变的缓慢，这样就得不偿失了。那么我们继续改进，看下面的方法：

2.2.Double Check Lock(DCL)实现单例

public class Singleton { 
     private Singleton(){} 
     private final static Singleton mInstance; 
     /*双重锁定:只在第一次初始化的时候加上同步锁*/  
     public static Singleton getInstance() { 
          if(mInstance == null){ 
              synchronized(Singleton.class){ 
                  if(mInstance == null){ 
                        mInstance = new Singleton(); 
                  }
              }
         } 
         return mInstance; 
     }
}```
这种双重锁定的方式，避免了每次获取实例时不必要的同步操作，只在第一次获取实例的时候才进行同步，将开销减到了最小，并且保证了线程安全。但是，真的是线程安全了么？问题其实出在mInstance = new Singleton();这句代码，虽然它只是一句代码，但是实际上它不是一个原子操作，这句代码最终会被编译成多条汇编指令，它大致做了3件事情：
（1）给Singleton的实例分配内存;
（2）调用Singleton()的构造函数，初始化成员字段;
（3）将mInstance对象指向分配的内存空间（此时mInstance就不是null了）。
由于Java编译器允许处理器乱序执行，以及JDK1.5之前JMM（Java Memory Model，即Java内存模型）中Cache、寄存器到内存回写顺序的规定，上面的第二和第三的顺序是无法保证的。也就是说，执行顺序可能是1-2-3也可能是1-3-2。如果是后者，并且在3执行完毕、2未执行之前，被切换到另一个线程上，就会出问题。但是在你的app没有太多的高并发存在时，这种模式已经可以完全满足大多数开发者的需求。那么一定还有更好的：
#### 2.3.静态内部类单例模式
```java
public class Singleton { 
     private Singleton(){} 
     private final static Singleton mInstance; 
     public static Singleton getInstance() { 
         return SingletonHolder.mInstance; 
     } 
     private static class SingletonHolder { 
         private final static Singleton mInstance = new Singleton(); 
     }
}

当第一次加载Singleton类的时候并不会初始化mInstance，只有在第一次调用getInstance方法时才会导致mInstance被初始化。因此，第一次调用getInstance方法会导致虚拟机加载SingletonHolder类，这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化，所以这是推荐使用的单例模式实现方式。Tip：java中的枚举其实也是单例的一种实现方式

三.结论

之前在对单例的了解并没有特别的系统，这次梳理了下，发现其实自己的工程中还是有很多不考虑线程安全的单例实现的，虽然在没有并发的情况下可能没有太大的影响，但是程序是需要有超前意识的，推荐大家也使用2.3的单例实现方式。