什么是单例模式

单例模式是23种设计模式中最简单和易用的模式。在某些情境下，如在一个上市公司中，有很多不同级别的员工，但是公司的CEO或者CTO都是只有一个的，CEO或者CTO在公司里就要求是一个单例。单例模式，就是某个类因实际情况的需要，要求在全局的范围内只能有唯一的实例对象，这个对象是常驻内存的，可以重复使用，降低重复创建对象的开销。

单例模式的特点

• 类的构造函数是私有的
• 在类内部实例化对象，并通过静态方法向外提供实例化的对象

下面主要讲解实现单例模式的方法以及它们的优缺点

单例模式的实现

单例模式的目的，就是要确保在全局范围内某个类的对象是唯一的。所以实现单例模式时，我们至少要考虑两个影响对象创建的因素。

• 在并发的环境下的线程安全
• 反序列化

饿汉实现

在类第一次加载时，就进行对象的实例化。

public class SingletonDemo {private final static SingletonDemo mSingletonDemo = new SingletonDemo();private SingletonDemo() {}public static SingletonDemo getInstance() {return mSingletonDemo;}}
复制代码

懒汉实现

在类加载时不进行对象的实例化，只在对象被第一次访问时，才进行对象的实例化。

public class SingletonDemo {private static SingletonDemo mSingletonDemo;private SingletonDemo() {}public static SingletonDemo getInstance() {if(mSingletonDemo == null) {mSingletonDemo = new SingletonDemo();}return mSingletonDemo;}}
复制代码

明显，在多线程的环境下，上面两种实现方式都不是线程安全的。为了实现线程安全，我们首先可以想到使用synchronized关键字。

线程安全的懒汉模式

public class SingletonDemo {private static SingletonDemo mSingletonDemo;private SingletonDemo() {}public static synchronized SingletonDemo getInstance() {if(mSingletonDemo == null) {mSingletonDemo = new SingletonDemo();}return mSingletonDemo;}}
复制代码

关于synchronized关键字说明一下，synchronized声明的静态方法，同时只能被一个执行线程访问，但是其他线程可以访问这个对象的非静态方法。即：两个线程可以同时访问一个对象的两个不同的synchronized方法，其中一个是静态方法，一个是非静态方法。

所以，当有多个线程同时访问getInstance静态方法时，多个其他的线程只能等待，这时只有一个线程能够访问getInstance方法，等这个线程释放后其他线程才能访问。这样就会影响速度和效率。

为了提高懒汉模式的速度和效率，可以减小锁的粒度和次数。

双重校验锁法

public class SingletonDemo {private static SingletonDemo mSingletonDemo;private SingletonDemo() {}public static synchronized SingletonDemo getInstance() {if(mSingletonDemo == null) {synchronized (SingletonDemo.class) {if(mSingletonDemo == null) {mSingletonDemo = new SingletonDemo();}}}return mSingletonDemo;}}
复制代码

从上面可以看到，只有在第一次访问时才会锁定和创建类的对象，之后的访问都是直接使用已经创建好的对象，这样减少锁定的次数和范围，以达到提高单例模式的效率。

但是，对象的实例化，并不是一个原子性操作。即第11行代码处，它可以分成下面三个步骤： 1、new SingletonDemo()，为SingletonDemo实例分配内存 2、调用SingletonDemo的构造器，完成初始化工作 3、将mSingletonDemo指向分配的内存空间

由于java处理器可以乱序执行，即无法保证2和3的执行顺序。这对双重校验锁法实现的单例模式有什么影响呢？ 当第一个线程访问getInstance方法时，会锁定临界区（第9行到第13行代码），它实例化对象的顺序是1=>3=>2，而在这时如果有第二个线程来访问getInstance方法，由于第一个线程在处理器中执行完了3未执行2，第二个线程会马上得到实例对象，因为第一个线程的3已经执行完即mSingletonDemo已经不为空。当第二个线程使用没有初始化的对象时就会出现问题。

所以，双重校验锁法也不是完美的，在并发环境下依然可能出现问题。

静态内部类实现

public class SingletonDemo {private static SingletonDemo mSingletonDemo;private SingletonDemo() {}private static class SingletonHolder {private static final SingletonDemo INSTANCE = new SingletonDemo();}public static SingletonDemo getInstance() {return SingletonHolder.INSTANCE;}}
复制代码

第一次加载SingletonDemo类时并不会实例化INSTANCE，只有在第一次调用getInstance方法时，才会加载SingletonHolder内部类，创建SingletonDemo实例。这种方式不仅确保了线程安全，也保证单例对象的唯一性，同时也实现了单例对象的懒加载。

枚举实现

上面几种实现方式，可能会因为反序列化而创建新的实例，所以必须重写readResolve方法，在readResolve方法中返回已经创建的单例。

使用枚举可以很简单的实现单例模式，这也是Effective Java中提倡的方式。因为枚举本身就是类型安全的，并且枚举实例在任何情况下都是单例。

public enum SingletonEnumDemo {INSTANCE;public void justDoYourThing() {}
}
复制代码

枚举单例使用

SingletonEnumDemo.INSTANCE.justDoYourThing();
复制代码

容器实现

public class SingletonDemo {private static Map<String, Object> singletonMap = new HashMap<String, Object>();private SingletonDemo() {}public static void registerService(String key, Object instance)     {if (!singletonMap.containsKey(key)) {singletonMap.put(key, instance);}}public static Object getService(String key) {return singletonMap.get(key);}}
复制代码