单利模式的介绍
单利模式是应用最广的模式之一，也可能是很多初级工程师唯一会使用的设计模式。在应用这个模式时，单利对象的类必须保证只有一个实例存在。许多情况下整个系统只需要拥有一个全局对象，这样有利于我们协调系统整体的行为，降低支援的消耗。
定义
确保只有一个实例，而且自行实例化并向这个系统提供这个实例。
单例模式使用场景(套路)
确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象应该有且只有一个。例如，创建一个对象需要消耗的资源过多，如访问IO和数据库等资源，这时候就要考虑使用单利模式。
单例模式UML类图
角色介绍：
（1）Client----高层客户端；
（2）Singleton----单利类
实现单例模式主要有如下几个关键点：
- 构造函数不对外开放，一般为private
- 通过一个静态方法或者枚举返回单利类对象
- 确保单利类的对象有且只有一个，尤其是在多线程环境下
- 确保单利类对象在反序列化是不会重新构建对象
注意：
通过将单利类的构造函数私有化，使得客户端代码不能通过new的形式手动构造单利类的对象。单利类会暴露一个共有静态方法，客户端需要调用这个静态方法获取到单利类的唯一对象，在获取这个单利对象的过程中需要确保线程安全，即在多线程环境下构造单利类的对象也是有且只有一个。
单利类的几种实现方式
1：饿汉式
public class SingleTon {
public static final SingleTon mInstance = new SingleTon();
//构造函数私有
private SingleTon() {
}
//公有的静态函数，对外暴露获取单利对象的接口
public static SingleTon getInstance(){
return mInstance;
}
}
从上述代码可知，SingleTon 类不能通过new的形式构造对象，只能通过
SingleTon.getInstance()函数获取，而这个对象时静态对象，并且在声明的时候就已经初始化，这就保证了SingleTon对象的唯一性。
2：懒汉式
懒汉式是声明一个静态对象，并且在用户第一次调用getInstance()时进行初始化
public class SingleTon {
public static SingleTon mInstance ;
//构造函数私有
private SingleTon() {
}
//公有的静态函数，对外暴露获取单利对象的接口
public static synchronized SingleTon getInstance(){
if (mInstance==null){
mInstance=new SingleTon();
}
return mInstance;
}
}
3：Double Check Lock(DCL)实现单利
public class SingleTon {
public static SingleTon mInstance;
//构造函数私有
private SingleTon() {
}
//公有的静态函数，对外暴露获取单利对象的接口
public static synchronized SingleTon getInstance() {
if (mInstance == null) {
synchronized (SingleTon.class) {
if (mInstance == null) {
mInstance = new SingleTon();
}
}
}
return mInstance;
}
}
双重锁的亮点在于双重判断，相对于懒汉式的写法，减少了没必要的同步判断。
- 第一层判断主要是避免不必要的同步
- 第二层判断是为了在null的情况下创建实例
那么DCL模式就没有缺点？
假设线程A执行到mInstance = new SingleTon();语句，这里看起来是一句代码，但实际上它并不是一个原子操作，这段代码最终会被变异成多条汇编指令，大致做了三件事：
(1)给mInstance 实例分配内存；
(2)调用Singleton()的构造函数，初始化成员字段
(3)将mInstace对象指向分配的内存空间（此时mInstace就不是null了）
如果指令按照顺序执行倒也无妨，但在jdk1.5之前，JVM为了优化指令，提高程序运行效率，允许指令重排序上面的执行顺序有可能是这样的
(a)给mInstance 实例分配内存；
(b)将mInstace对象指向分配的内存空间（此时mInstace就不是null了）
(c)调用Singleton()的构造函数，初始化成员字段
如果是后者，并且执行完了b操作(c操作之前)，被切换到线程B，这时候mInstance 因为已经在线程A执行了b操作，mInstance 不为空，所以线程B直接取走mInstance ，在使用时就会出错，这就是DCL失效问题。
具体来说就是synchronized虽然保证了线程的原子性（即synchronized块中的语句要么全部执行，要么一条也不执行），但单条语句编译后形成的指令并不是一个原子操作（即可能该条语句的部分指令未得到执行，就被切换到另一个线程了）。
根据以上分析可知，解决这个问题的方法是：禁止指令重排序优化，即使用volatile变量。
public class SingleTon {
public volatile static SingleTon mInstance;
//构造函数私有
private SingleTon() {
}
//公有的静态函数，对外暴露获取单利对象的接口
public static synchronized SingleTon getInstance() {
if (mInstance == null) {
synchronized (SingleTon.class) {
if (mInstance == null) {
mInstance = new SingleTon();
}
}
}
return mInstance;
}
}
4：静态内部类单利模式
public class SingleTon {
public volatile static SingleTon mInstance;
//构造函数私有
private SingleTon() {
}
public static SingleTon getInstance() {
return SingletonHolder.mInstance;
}
/**
* 静态内部类
*/
private static class SingletonHolder {
private static final SingleTon mInstance = new SingleTon();
}
}
当第一次加在Singleton类时并不会初始化mInstace，只有在第一次调用
SingleTon.getInstance()方法时才会导致mInstace被初始化。因此，第一次调用getInstace()方法会导致虚拟机加在SingletonHolder类。这种方式不仅能够确保线程安全，也能保证单利对象的唯一性，同时也延迟了单利的实例化，所以这是土建使用的单利模式实现方式。
5：枚举单利
public enum SingleTon {
INSTANCE;
public void doSomething(){
System.out.println("do sth...");
}
}
有点：
- 实现方式简单
- 默认情况下枚举实例的创建是线程安全的，并且在任何情况下它都是一个单利。
6：使用容器实现单利模式
public class SingletonManager {
private static Map<String, Object> objectMap = new HashMap<>();
private SingletonManager() {
}
public static void registerServiec(String key, Object instance) {
if (!objectMap.containsKey(key)) {
objectMap.put(key, instance);
}
}
public static Object getService(String key) {
return objectMap.get(key);
}
}
在程序的初始，将多种单利类型注入到一个统一的管理类中，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单利，并且在使用时可以通过统一的接口进行后去操作，降低用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。
单利模式的实例--Activity的管理
public class ActivityManager {
private static volatile ActivityManager mInstance;
// 集合用谁 List LinkedList Stack ?? 删除和添加比较多
private Stack<Activity> mActivities;
private ActivityManager(){
mActivities = new Stack<>();
}
// 虽说解决了线程安全的问题，但是又会出现效率的问题，
// 即保证线程的安全同是效率也是比较高的
// 这种方式其实还是会有问题？
public static ActivityManager getInstance() {
if (mInstance == null) {
synchronized (ActivityManager.class) {
if (mInstance == null) {
mInstance = new ActivityManager();
}
}
}
return mInstance;
}
/**
* 添加统一管理
* @param activity
*/
public void attach(Activity activity){
mActivities.add(activity);
}
/**
* 移除解绑 - 防止内存泄漏
* @param detachActivity
*/
public void detach(Activity detachActivity){
// for 去移除有没有问题？ 一边循环一边移除会出问题 ，
// 既然这个写法有问题，自己又想不到什么解决方法，参考一下别人怎么写的
/*for (Activity activity : mActivities) {
if(activity == detachActivity){
mActivities.remove(activity);
}
}*/
int size = mActivities.size();
for (int i = 0; i < size; i++) {
Activity activity = mActivities.get(i);
if (activity == detachActivity) {
mActivities.remove(i);
i--;
size--;
}
}
}
/**
* 关闭当前的 Activity
* @param finishActivity
*/
public void finish(Activity finishActivity){
// for 去移除有没有问题？
/*for (Activity activity : mActivities) {
if(activity == finishActivity){
mActivities.remove(activity);
activity.finish();
}
}
*/
int size = mActivities.size();
for (int i = 0; i < size; i++) {
Activity activity = mActivities.get(i);
if (activity == finishActivity) {
mActivities.remove(i);
activity.finish();
i--;
size--;
}
}
}
/**
* 根据Activity的类名关闭 Activity
*/
public void finish(Class<? extends Activity> activityClass){
// for 去移除有没有问题？
/*for (Activity activity : mActivities) {
if(activity.getClass().getCanonicalName().equals(activityClass.getCanonicalName())){
mActivities.remove(activity);
activity.finish();
}
}*/
int size = mActivities.size();
for (int i = 0; i < size; i++) {
Activity activity = mActivities.get(i);
if (activity.getClass().getCanonicalName().equals(activityClass.getCanonicalName())) {
mActivities.remove(i);
activity.finish();
i--;
size--;
}
}
}
/**
* 退出整个应用
*/
public void exitApplication(){
}
/**
* 获取当前的Activity（最前面）
* @return
*/
public Activity currentActivity(){
return mActivities.lastElement();
}
}
