用途
所谓单例模式就是整个程序有且仅有一个实例。该类负责自己创建对象，有且仅有一个对象被创造，并提供一个访问该实例的方法。
应用例子
- 一个班级只有一个班主任。
- Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
- 一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。
几种实现方式
1.懒汉式，线程不安全
- 是否线程安全：否
- 是否 Lazy 初始化：是
public class Singleton {
private static Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
为防止被外部类调用创建对象，需将构造方法私有化，为防止反射调用可在构造方法中加判断，需将代码做如下改动：
public class Singleton {
private static Singleton instance;
//构造方法私有化
private Singleton() {
if(null != instance){
throw new IllegalStateException("该实例已被创造");
}
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
这样做每次获取实例前都会去判断该对象是否为null,是的话则会实例化一个该对象，如果存在则直接返回。看似完美，可是存在多线程并发同时创建对象，则该方法就不是单例了。
2.懒汉式，线程安全
- 是否线程安全：是
- 是否 Lazy 初始化：是
2.1 在getInstance方法上加synchronized关键字
public class Singleton {
private static Singleton instance;
//构造方法私有化
private Singleton() {
}
public synchronized static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
这样写保证了同一时间只有一个线程会进入getInstance的方法，但是锁的方法太大，其他所有线程都要等待，造成系统资源的浪费，我们可以考虑将锁的方法缩小，采用2.2方法优化。
2.2 使用对象锁只有当instance为null时，才执行同步代码块
public class Singleton {
private static Singleton instance;
//构造方法私有化
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
}
该方法只有在instance为null时，才会去执行同步代码块，看似非常完美，但在高并发下仍然有可能会出现并发问题，因为在计算机中，为了提高运行效率，为了性能考虑, 编译器和CPU可能会对指令重新排序，例如：
int a; //语句 A
a = 3; //语句 B
int b = 5; //语句 C
int c = a + b; //语句 D
由于A、C之间的语句无关性，指令可能会被排序为A->B->C->D或C->A->B->D。
我们都知道对象的创建instance = new Singleton(); 需要经过内存分配然后初始化的操作(该操作并非原子性)，因此指令重排可能会出现instance已经被分配内存但未被初始化状态，执行判空的线程抢在了初始化的操作完成之前，则直接返回 instance 肯定会报错，因此为防止指令重排的操作，我们可以通过使用volatile防止指令重排，因此有了2.3最终版。
2.3 双检锁方式（推荐）
public class Singleton {
private static volatile Singleton instance;
//构造方法私有化
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
}
3.饿汉式，线程安全
- 是否线程安全：是
- 是否 Lazy 初始化：否
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
这种方式实现简单且执行效率高。而且它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达lazy loading的效果。
4.静态内部类
- 是否线程安全：是
- 是否 Lazy 初始化：是
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
这种方式能达到2.3一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。
5.枚举(需要反序列化创建对象时推荐)
- 是否线程安全：是
- 是否 Lazy 初始化：否
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}
这是实现单例模式的最佳方法。它更简洁它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象(防止序列化破坏单例模式)，绝对防止多次实例化。
参考文档：
