作用： 一个类提供一个可供全局调用的单一实例（全局仅有一个实例）。
分类： 常用的单例模式有：饿汉式、懒汉式、枚举、静态内部类。下面对他们进行详细介绍。
1、饿汉式
饿汉式就是在第一次调用该类的时候就创建该类的实例对象。如下：
public class Singleton {
public Singleton() {
}
/**
* 不管需不需要，直接初始化对象
*/
private static Singleton singleInstance = new Singleton();
/**
* 使用时，直接调用即可
*/
public Singleton getSingleInstance() {
return singleInstance;
}
}
缺点：不管使用不使用，都对该类进行了初始化，无法实现延迟加载（也称懒加载，延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。）
2、懒汉式
懒汉式就是在需要的时候创建相应的实例，避免一些无谓的性能开销。如下：
public class Singleton {
private static volatile Singleton singleInstance = null;//第四步
/**
* 使用时，直接调用即可
*/
public Singleton getSingleInstance() {
if (singleInstance == null) {//第一步
synchronized (Singleton.class) {//第二步
if (singleInstance == null) {
singleInstance = new Singleton();//第三步
}
}
}
return singleInstance;
}
}
分析：
第一步：首先判断实例是否为空，避免每次调用都执行同步锁，减少不必要的开销
第二步：同步锁（监控当前只能有一个线程在执行该方法，通过锁定监视器与解锁控制下一个线程在本线程执行该步骤之后），好处：线程安全。
第三步：实例化对象，这里是线程不安全的。原因：这里可以分为三步：
（1）memory =allocate(); //给对象分配内存空间
（2）ctorInstance(memory); //初始化对象（内存空间）
（3）singleInstance=memory； //给singleInstance赋值（设置singleInstance指向的内存地址）
（2）依赖于（1），（3）依赖于（1），但是（2）、（3）互相没有关系，所以根据JVM指令重排的规则，他们的执行顺序可能是（1）->（2）->（3），也可能是（1）->（3）->（2）。当多个线程同时执行该单例方法是，可能上一线程的（1）、（3）执行的了，下一个线程进入发现singleInstance不为空，直接返回了，这时候其实singleInstance并没有完全初始化，就会报错。这就需要第四步的volatile来解决问题。
第四步：volatile可以禁止JVM指令重排，同时保证不同线程对同一变量操作的可见性，当新线程对一变量就行修改后，该变量在其他线程立即见效。
好处：线程安全，效率高，延迟加载
缺点：别人可以通过反射调用自己的私有构造器；需要额外的工作(Serializable、transient、readResolve())来实现序列化，否则每次反序列化一个序列化的对象实例时都会创建一个新的实例。
3、枚举
枚举也是一种简单的单例模式，如下：
public enum Singleton {
instance;
private String singleInstance;
public String getSingleInstance() {
return singleInstance;
}
public void setSingleInstance(String singleInstance) {
this.singleInstance = singleInstance;
}
}
优点：线程安全；防止反射强行调用构造器；自动序列化
4、静态内部类
静态内部类也是一种线程安全的写法，如下：
public class Singleton {
public Singleton() {
}
/**
* 静态内部类中初始化对象
*/
private static class InnerClass {
private static Singleton singleton = new Singleton();
}
/**
* 使用时直接调用
*
* @return
*/
public static Singleton getSingleInstance() {
return InnerClass.singleton;
}
}
优点：线程安全，延迟加载（调用时初始化，减少内存开销）。
缺点：别人可以通过反射调用自己的私有构造器；需要额外的工作(Serializable、transient、readResolve())来实现序列化，否则每次反序列化一个序列化的对象实例时都会创建一个新的实例。
