概述
有时候我们在写程序的时候，我们希望在全局共用一个对象。比如一个负责读取全局配置文件的类A，读取一次配置文件之后，使用单例模式，我们可以得到一个全局唯一的对象a，其他对象读取配置时就不用重复实例化类A，并重复读取配置文件了。
总之，单例模式保证了某个类全局只存在一个实例。
单例模式的实现一般可以分为以下几类
- 懒汉式（非线程安全）
- 懒汉式（线程安全）
- 饿汉式
- 双重检查锁
- 静态内部类
- 枚举
下面简要介绍上述实现方法
懒汉式（非线程安全）
先上代码
/**
* 懒汉模式，非线程安全
*/
public class SingleTon() {
private static SingleTon instance;
private SingleTon() {}
public static SingleTon getInstance() {
if (instance == null) {
instance = new SingleTon();
}
return instance;
}
}
懒汉模式只所以叫懒汉，是因为他使用了“惰性加载（Lazy Initialization）”的思想(好吧，这是我瞎猜的)
为了防止单例类被其他类new出来，我们将单例类的构造函数设为private。在单线程模式下，这个单例是可用的，但是一旦在多线程的情况下，可能会有多个线程进入if语句，导致单例产生多个实例。
总之，该实现方式使用了惰性加载技术，但是非线程安全，不推荐使用。
懒汉式（线程安全）
在之前的基础上，为了保证懒汉式单例模式的线程安全，我们利用Java的synchronized关键字保证其线程安全。其代码如下。
public class SingleTon() {
private static SingleTon instance;
private SingleTon() {}
public static synchronized getInstance() {
if (instance == null) {
instance = new SingleTon();
}
return instance;
}
}
使用了synchronized关键字对getInstance方法修饰后，我们保证了懒汉式的线程安全性。但是该模式存在一个致命的问题，那就是性能问题。
假设SingleTon类的instance已经被实例化了，如果有多个线程调用getInstance时，只有一个线程能获得锁，其他线程都不得不等待，这会影响系统的性能。
总之，线程安全的懒汉式同样使用了惰性加载技术，并且是线程安全的，但是并发性能并不是很好。那么怎么解决这个问题，并能保证线程安全和使用懒加载呢？答案是“双重检验锁”。
双重检验锁
先看代码
public class SingleTon {
private static SingleTon instance;
public static SingleTon getInstance() {
if (instance == null) {
synchronized(SingleTon.class) {
if (instance == null) {
instance = new SingleTon();
}
}
}
return instance;
}
}
如上面代码所示，如果第一次检查instance不为null，那么就不需要执行下面的加锁和初始化操作。因此可以大幅降低synchronized带来的性能开销。
看似这段代码可以很好的实现单例模式了，但是这段代码有一个隐藏的BUG。原因在instance = new SingleTon()这句话，因为JVM在执行这句代码的时候，大概进行了以下3个步骤：
- 为SingleTon分配内存。
- 调用SingleTon的构造函数进行初始化。
- 将instance指针指向分配好的地址。
理想执行顺序是1->2->3，之前的代码不会有问题。然而由于某些JIT编译器存在指令重排序，可能会出现1->3->2的指令执行顺序，这时可能会导致线程1执行完3以后，另外一个线程抢占使用instance，那么就会出现错误。
解决这个问题的办法很简单，只需要将 instance 变量声明成 volatile 就可以了。
volatileu关键字有两个功能：
- 保证变量的内存可见性
- 局部阻止重排序的发生
这里我们用到了第二个功能，保证了单例模式的正常实现。修改后的代码如下：
public class SingleTon {
private volatile static SingleTon instance;
public static SingleTon getInstance() {
if (instance == null) {
synchronized(SingleTon.class) {
if (instance == null) {
instance = new SingleTon();
}
}
}
return instance;
}
}
通过上面的代码，我们就可以愉快地使用单例模式了。这是一种比较线程安全且用到了惰性加载技术的单例模式实现方法。
饿汉模式
这里介绍另外一种不适用惰性加载技术的单例模式实现方法，不使用惰性加载之后，代码也变得简洁了许多。代码如下。
public class SingleTon() {
private static final SingleTon instance = new SingleTon();
private SingleTon() {}
public static SingleTon getInstance() {
return instance;
}
}
可以看到，这种单例模式在类加载期间就会初始化instance实例，JVM会保证多个线程初始化一个类的时候只有一个类执行，所以我们不用担心线程安全问题。
静态内部类方法
代码如下
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
原理同饿汉式类似，不在啰嗦。
枚举类方法
Java自身的枚举类能够保证全局只存在有限个实例，并能线程安全的访问。代码也非常简洁。
public enum SingleTon() {
INSTANCE;
}
总结
本文，我们介绍了6种单例模式的实现方法，我们可以根据不同的业务场景来实现单例模式。当然，实现单例模式的时候我们不光关注惰性加载和线程安全，序列化反序列化问题也是单例模式的一个问题，且看下回分解。
