说到单例模式，顾名思义可以知道指的是一个类在整个系统中有且只有一个实例，就像古代的皇帝一样是唯一的唯吾独尊的。那我们今天就来研究一下这个霸道的“单例模式”。
首先我们来看看，单例模式的定义:一个类有且仅有一个实例,并且自行实例化并向整个系统提供。那么实现单例的步骤有哪些呢？
既然单例模式要求有且只有一个实例，那首先得私有化构造函数——让用户不能自行new出对象。
要求要自行实例化并向整个系统提供该实例，那就得自己new出一个唯一的实例，并提供一个公有静态的方法向外提供这个实例。
public class Emperor {
//1、私有化构造函数
private Emperor() {
}
//2、自行实例化出一个唯一的对象
private static Emperor mEmperor = new Emperor();
//3、向外提供一个公有的静态方法用于获取该唯一实例
public static Emperor getInstance(){
return mEmperor;
}
}
从上述代码我们可以发现，确实实现了单例模式，但是该Emperor类，在类加载的时候就实例化出了mHungryEmperor实例，这就是传说中的“饿汉式”。这显然不是我们希望看到的，我们希望在我们需要该实例的时候再去创建，那我们再将代码改一下：
public class LazyEmperor {
//1、私有化构造函数。
private LazyEmperor() {
}
//2、声明一个LazyEmperor成员变量。
private static LazyEmperor mLazyEmperor;
//3、提供一个公有的静态方法向外提供唯一实例,先判断该实例是否存在,不存在再new
public static LazyEmperor getInstance(){
if (mLazyEmperor == null){
mLazyEmperor = new LazyEmperor();
}
return mLazyEmperor;
}
}
从上述代码我们可以看到，是当我们调用getInstance方法的时候才将mLazyEmperor对象创建出来，不会过早创建，这就是传说中的“懒汉式”。但是由于这里存在判断，那么我们肯定要考虑线程安全的问题，当多线程并发访问的时候会不会出现线程不安全的情况呢？我们举个例子：
假如现在有A、B两个线程同时访问该LazyEmperor类，当A线程走到getInstance方法的时候判断mLazyEmperor是否为空，此时肯定是为空的，那么A线程准备new 一个LazyEmperor对象。但是A线程还没来得及new的时候B线程也走到了getInstance方法判断mLazyEmperor是否为空，显然此时还是为空的，那么B线程也准备new一个LazyEmperor对象。此时就有了两个LazyEmperor对象，就不符合单例模式的要求了。
那么，我们怎么解决这类问题呢？针对线程安全性问题，我们一般的方法是使用synchronized加锁：
public class LazyEmperor {
//1、私有化构造函数。
private LazyEmperor() {
}
//2、声明一个LazyEmperor成员变量。
private static LazyEmperor mLazyEmperor;
//3、提供一个公有的静态方法向外提供唯一实例,先判断该实例是否存在,不存在再new
public synchronized static LazyEmperor getInstance(){
if (mLazyEmperor == null){
mLazyEmperor = new LazyEmperor();
}
return mLazyEmperor;
}
}
但是我们都知道，synchronized给系统带来的消耗较大，如果像上述代码所示，那么每次调用getInstance方法都得加锁，这样难免会给系统带来不必要的消耗。我们的想法是：在需要加锁的时候再加锁，也就是需要考虑线程安全性的时候使用synchronize。如果mLazyEmperor不为空，则不需要考虑线程安全问题。那我们再将代码改一下：
public class LazyEmperor {
//1、私有化构造函数。
private LazyEmperor() {
}
//2、声明一个LazyEmperor成员变量。
private static LazyEmperor mLazyEmperor;
//3、提供一个公有的静态方法向外提供唯一实例,先判断该实例是否存在,不存在再new
public static LazyEmperor getInstance(){
//第一次判断是为了减少不必要的加锁
if (mLazyEmperor == null){
synchronized(LazyEmperor.class){
//第二次判断是为了确保只有一个对象
if (mLazyEmperor == null){
mLazyEmperor = new LazyEmperor();
}
}
}
return mLazyEmperor;
}
}
上述代码就是传说中的“双重判断锁机制”，既保证了在多线程并发访问的情况下能保持单例，又满足了在需要的时候才创建实例，不会过早创建。
但是人总是不满足的，“双重判断锁机制”虽然好，但它还是用到了synchronize，多少会带来一些不必要的消耗。如果能不使用synchronize就能既保证了在多线程并发访问的情况下能保持单例，又满足了在需要的时候才创建实例就好了。那我们来看一下下面这种写法吧：
public class Emperor {
//私有化构造函数
private Emperor() {
}
//声明一个静态类,为该类的静态成员变量赋值为Emperor的唯一实例
private static class SingleInstance{
private static Emperor INSTANCE = new Emperor();
}
//声明一个公有的静态方法获取唯一实例
public static Emperor getInstance(){
return SingleInstance.INSTANCE;
}
}
上面这种写法是不是很新奇，从上述代码可以看出，当静态内部类加载的时候才会创建实例，也就是调用getInstance方法的时候才会创建实例，保证了不会过早创建。而且这种写法也不会出现线程安全问题，反正只会在静态内部类实例化的时候创建一次对象。
以上方法当然已经很好了，但是如果要考虑到反序列化的时候会重新创建对象的话，“静态内部类”实现单例显然还不是最佳的方法，那么那种方法能够防止反序列化时重复创建实例呢？——那就是使用枚举来实现单例：
public enum EnumEmperor {
INSTANCE;
private EnumEmperor() {
//初始化实例时该做的事
}
//任何方法
public void doAnything(){
}
}
当我们要使用该单例对象的时候，我们就这样做：
EnumEmperor.INSTANCE.doAnything();
这样，既确保了线程安全，也确保了反序列化时不会重复创建对象。
以上就是单例的多种写法，建议使用静态内部类和enum的形式来设计单例。因为enum是JDK1.5之后才引入的，所以使用时要注意JDK版本。
