定义
一个类只有一个实例，自行实例化并提供给整个系统
基本思路
将该类构造函数私有化，并通过静态方法获取一个唯一实例，获取过程保证线程安全
懒汉式线程不安全写法
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (null == instance) {
instance = new Singleton();
}
return instance;
}
}
假设有A、B线程同时调用getInstance方法，在分水岭同时执行完判断后，有CPU时间片切换，假设A线程得到执行权，继续向下执行，实例化了对象，此时instance不为空，而B线程又做了实例化工作，就会导致实例不唯一。
懒汉式线程安全
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static synchronized Singleton getInstance() {
if (null == instance) {
instance = new Singleton();
}
return instance;
}
}
在getInstance()方法前加上synchronized，使整个方法同步，就可以保证线程安全，避免多实例的问题，但是这样并不高效，因为在第一次调用getInstance()方法后，instance不为空，之后再调用该方法就要走同步，这样会消耗不必要的资源。
Double Check Lock(双重检验锁)
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (null == instance) {
synchronized (Singleton.class) {
if (null == instance) {
instance = new Singleton();
}
}
}
return instance;
}
}
这里为啥要做两次检验呢？我们先来看下，如果去掉第一层检验会怎样
public static Singleton getInstance() {
synchronized (Singleton.class) {
if (null == instance) {
instance = new Singleton();
}
}
return instance;
}
当有两个线程同时调用getInstance()方法时，由于同步机制的存在，假设此时A线程得到CPU的执行权，走到同步块中执行，执行了instance = new Singleton()后，退出同步语句块，此时instance已经不为null了，这时候B线程获得CPU执行权也进入同步块，就会被instance == null的判断挡在外面了。所以就算不要第一层检验也是可以实现多线程安全的单例，那为毛还要写？原来这里涉及到性能问题，上面懒汉式线程安全的写法也是安全的，但是每次调用都要走同步会影响性能，这里也一样。我们希望这里的new Singleton()只执行一次，如果少了第一层的判断，每次有线程进入getInstance()时，均会执行锁定操作来实现线程同步，这是非常耗费性能的，而多了第一层检验，只要第一次instance==null会执行锁定操作，之后的调用直接return instance就行。
再看如果少了第二层检验，其实这就跟第一种懒汉式线程不安全写法一样，在多线程并发的情况下不能达到保持单例的效果。
那么双重检验机制是否就能完美解决问题？其实不然，其原因在于instance == new Singleton();这句并非是个原子操作，当JVM执行到这一句时，分别作了如下操作：
- 在堆中为instance 分配内存
- 调用Singleton的构造函数初始化成员变量
- 将instance对象执行分配的内存空间（执行完这步instance就为非null了）
如果上面的操作按1-2-3顺序执行，那就没啥问题，但是由于JVM的即时编译器中存在指令重排序的优化，上面的操作有可能是1-3-2。这会出现啥情况？
public static Singleton getSingleton() {
if (instance == null) { //p2
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton(); //p1
}
}
}
return instance ;
}
假设线程A此时走到p1处，JVM按照1-3-2的顺序实例化instance，才执行完1-3，来不及执行2，线程B获得了CPU执行权也调用了getInstance()方法，并走到p2处，此时instance不为null，线程B就屁颠屁颠拿着得到的实例回去干活了，但是里头的成员变量还没初始化，这就尴尬了，报错也就理所当然了。
要解决这问题只要把instance设置成volatile，禁止重排序优化，以上面的例子，不管是1-2-2还是1-3-2，读取必须在操作完全执行完后才能进行。
public class Singleton {
private volatile static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (null == instance) {
synchronized (Singleton.class) {
if (null == instance) {
instance = new Singleton();
}
}
}
return instance;
}
}
然而java5以前的版本使用volatile还是有问题，也不能完全避免重排序。
恶汉式
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
}
由于instance被static和final修饰，在该类第一次被加载到内存中时就会对instance实例化，这样保证了单例。缺点是就算其他地方没有调用getInstance()方法，也会创建实例。
静态内部类
public class Singleton {
private Singleton() {
}
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
静态内部类就比较好的弥补了恶汉式单例不足，也是比较推崇的写法。
