引言
工欲善其事必先利其器 -------------------- 《论语·卫灵公》
最近在研究一些开源的项目，发现自己阅读上还存在不少问题。为了提高自己阅读代码的效率，决定再把设计模式整一遍。挨个来吧，首先是单例。
什么是单例
单例的定义很简单，一个类中只有一个实例对象。
这特么是个啥？抽象的概念。到底是个啥，在哪用到，为什么用，怎么用？我们先看看我们经常看到的一些代码：
比如这是网络框架okgo的代码: OkGo.getInstance().init(this); 这是OKGO使用的时候要进行的初始化操作，要放在Application中。我们点进去看看这个方法到底是个啥：
public static OkGo getInstance() {
return OkGoHolder.holder;
}
private static class OkGoHolder {
private static OkGo holder = new OkGo();
}
这神似xxx.getInstance()的这种操作一般就是单例。
为什么用单例
还是要从概念入手，只有一个实例对象。我们想想一下场景，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。（我们说的是这里只需要打印一份文件。。）编程里面很多时候是为了节约资源消耗（不断的New 有点麻烦的尤其是IO），还有就是数据库中，保证同一时间只有一个对象修改数据。
怎么用单例
这个就厉害了，我们看一下我们的代码，有没有这样的操作：
public clasa main{
ArrayList<String> list = new ArrayList<>();
private void setString(){
.....
list.add("");
}
private void clear(){
....
list.clear();
}
}
在这里，我们其实就用到了单例的思想，整个类里面就只用一个list对象，这个对象进行所有的操作，增删改查。在一个类里面我们也应该用过比如一个全局的index 他也表示了唯一，做一个记数。当然这里只是思想差不多而已，假如 在这个类的某个方法里面调用了一个 list = new ArrayList<>(); 那怎么办？ 我们来看看真正的JAVA中的单例吧。
1.饿汉模式
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
这个类刚被加载的时候 自己就偷偷的初始化了一个instance,所以你不管你用不用反正他是存在了。用起来直接 Singleton s = Singleton.getInstance(); 然后调用内部方法就Ok。还有一点要注意 就是这里的 private Singleton (){} 这里设置private 不再允许外部new 一个对象出来。这样就避免了上面那个list 别人再new一个出来导致问题。
2.懒汉模式
在说这个模式之前我们先了解一个概念，lazy loading , 说通俗一点，你用到我把我造出来，不用的时候我没有存在的必要。跟上面的模式的差别在这个是否懒加载上。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
这个是很基础的单例，拿到手创建对象 然后只要调用了getInstance()方法，那么这个对象就被创建了。
3.懒汉模式线程安全
上面那个模式 假如有两个方法在同一个时间调用了getInstance方法怎么办，那就会出现两个对象，虽然同时做这个初始化好像不怎么可能，但是我概率论老师说过，小概率事是有可能发生的。那就出现了线程安全的方法。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
关键词 synchronized 他会检测是否同步进行。保证只有一个。当然多个synchronized 会稍微延迟一丢丢，其实跟我们并没有什么大影响。
4.双检锁/双重校验锁（DCL，即 double-checked locking）
public class Singleton {
private static Singleton singleton = null;
private Singleton (){}
public static Singleton getInstance() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
代码一下子变多了那么他的功能呢，既能懒加载，又能保证线程安全。调用getInstace()的时候不进行同步锁。
5.枚举单例
public enum SingletonEnum {
INSTANCE;
public void doSomeThing(){
....
}
}
这个线程安全保证只有一个，但是怕反序列化会出现多个对象。
基本上都介绍的差不多了，我们来看看篇头的那个单例：
public class Singleton {
private Singleton(){}
private static class SingletonHolder{
public static Singleton singleton = new Singleton();
}
public Singleton getInstance(){
return SingletonHolder.singleton;
}
}
这个是进化版的DCL，静态内部类单例模式，推荐使用。
总结
单例是个基本的设计模式，有一些优缺点。但是基本上任何一个程序都会出现单例，源码中很多都带有这个设计模式。先有个认知。后面看代码会舒服很多。
