个人博客： http://zhangsunyucong.top
什么是单例模式
单例模式是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);
}
}
