Android单利模式

定义

作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

特点

单利类只能有一个实例
单利类必须自己创建自己的唯一实例
单利类必须给所有其他对象提供这一实例

创建单利模式的方法

1. 饿汉式

特点：

线程安全（因为提前创建，所以是天生线程安全）
此时单例因为有static修饰，因此在类加载的时候就会初始化，这对应用的启动会造成一定程度的影响。

写法一：
public class ClassName {
   private static ClassName instance = new ClassName (); // 饿汉模式，之间实例化
   private ClassName () {}
   public static ClassName getInstance(){
       return instance;
   }
}
写法二：
public class ClassName  {
  public static final ClassName instance = new ClassName ();
  private ClassName () {}
}

2. 懒汉式

初级版本

 public class ClassName {
    private static ClassName single = null;
    private ClassName (){}
    public static ClassName getInsgtance(){//同步
        if(single==null){
            single = new ClassName ();
        }
        return single;
    }
 }

特点：

线程不安全（并发时可能出现多个单利）
使用static关键字，表明全局只有一份节约了，但是如果单利对象比较复杂，new时就比较耗时间，

升级版本：使用synchronized 同步

 public class ClassName {
    private static ClassName single = null;
    private ClassName (){}
    public static synchronized ClassName getInsgtance(){//同步
        if(single==null){
            single = new ClassName ();
        }
        return single;
    }
 }

特点：
1.线程安全
2.因为加了锁，此时如果单例对象复杂，不仅耗内存，而且new的时间更长，效率更低。
但是上面这种效率不高还有另外一个原因，一个线程过来想要创建单利，首先要进行synchronized锁判断，接下来判断单利是否为空，如果为空，那么就创建单利。
既然上面每个线程过来都需要锁判断和单例是否为空的判断，这样做有点耗时，毕竟锁判断是比较耗时的。

3.双重校验锁模式（Double Check Lock 简称DCK）可用

public class ClassName {
private static volatile ClassName  singleton ;  //避免指令重排
   private ClassName (){}

public static ClassName getInstance() {
  //第一次检查
   if (singleton == null) {  
     synchronized (ClassName .class) {
        //第二次检查
        if (singleton == null) {  
           singleton = new ClassName ();
        }  
    }  
  }  
  return singleton;
}

为了解决上面饿汉式的问题，所以有了双重检验锁定
特点
1.线程安全
2.耗内存，而且单利对象比较复杂，比较耗时，但是相对电重锁效率提升不少
此时为了减少锁的判断量，只需要要对单利进行判断即可，如果不为空直接返回，如果为空，那么创建新的实例
注意：volatile 的引用，在这个版本之前有没有引入 volatile 的版本存隐患，
因为single = new ClassName ()这行代码并不是一个原子操作，这句代码最终会被编译成多条汇编指令，它大致做了3件事：

给ClassName 的实例分配内存
调用ClassName ()的构造函数，初始化成员字段
将single对象指向分配的内存空间（此时single已经不为null）

但是由于Java编译器允许处理器乱序执行，导致上面的2，3的顺序无法保证，如果是3执行完毕，2未执行之前被切换到线程B上，这时候single因为已经在线程A内执行过了3，single已经不是null了，所以，线程B直接取走single，再使用时就会出错。

所以引入了由于volatile既可以保证有序性又可以保证可见性，所以看到很多文章甚至一些书本在双重检查锁中说使用volatile是保证了可见性，即保证single对象每次都是从主内存中读取。
请参考
Java中的volatile关键字详解及单例模式双检锁问题分析
volatile关键字在单例模式中的应用

4.静态内部单利模式(推荐)

public class ClassName {
    private ClassName (){}
    public static ClassName getInstance(){
        return SingletonHolder.single;
    }

    private static class SingletonHolder{
        private static final ClassName single = new ClassName ();
    }
 }

特点：
1.线程安全当第一次加载ClassName 类时并不会初始化single，只有在第一次调用ClassName 的getInstance方法时才会导致single被初始化。因此，第一次调用getInstance方法会导致虚拟机加载SingleHolder类
2.效率高，避免了synchronized带来的性能影响
这种就好很多。很多大佬都推荐

5. 枚举式

public enum ClassName {
   INSTANCE;
   // 枚举同普通类一样，可以有自己的成员变量和方法
   public void getInstance() {
       System.out.println("Do whatever you want");
  }
}

特点：

线程安全(枚举类型默认就是安全的)
避免反序列化破坏单例
枚举类型更好，但是枚举类型会造成更多的内存消耗。枚举会比使用静态变量多消耗两倍的内存，如果是Android应用，尽量避免。原因的话，是因为枚举类型会在编译时转化为一个类，会涉及很多复杂的操作，这里就先不逼逼了。