七种单例模式
什么是设计模式？简单的理解就是前人留下来的一些经验总结而已，然后把这些经验起了个名字叫Design Pattern，翻译过来就是设计模式，通过使用设计模式可以让我们的代码复用性更高，可维护性更高，让你的代码写的更优雅。设计模式理论上有23种，今天就先来学习下最常用的单例模式。
单例模式
保证一个类仅有一个实例，并提供一个访问它的全局访问点。
写单例模式有7中方法，各有利弊，下面逐个分析
1、饿汉式
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){
}
public static Singleton getInstance() {
return instance;
}
}
这种方式创建的单例和名字很贴切，饥不择食，在JVM加载类的时候就创建了实例对象，不管你用还是不用，先创建了再说。
如果一直没有使用，便浪费了空间，典型的空间换时间的做法，每次调用的时候，就不需要再判断，节省了运行时间。
饿汉式单例实现比较简单，单例对象在初始化的时候就创建了，适合单例对象占用内存比较小的情况。
但是，如果单例初始化操作比较耗时，或者单例占用内存比较大，或者单例在某种特定情况才会使用，一般情况不会使用，这个时候使用饿汉式单例模式就不适合。需要使用懒汉式单例按需延时加载。
2、饿汉式(非线程安全)
public class SingletonLazyNotSafe {
private static SingletonLazyNotSafe instance = null;
private SingletonLazyNotSafe() {
}
public static SingletonLazyNotSafe getInstance() {
if (instance == null) {
instance = new SingletonLazyNotSafe();
}
return instance;
}
}
这种方式创建的单例对象，因为声明了一个静态对象该值为空，在JVM加载类的时候，并不会创建实例对象，节省了资源，只有在第一次调用getInstance()才会初始化对象。
但是这种模式的不能工作在多线程中，在多线程调用getInstance()可能会产生多个实例对象。
3、懒汉式(线程安全)
public class SingletonSafe {
private static SingletonSafe instance = null;
private SingletonSafe() {
}
public static synchronized SingletonSafe getInstance() {
if (instance == null) {
instance = new SingletonSafe();
}
return instance;
}
}
这种单例模式在getInstance()的方法前面加上了synchronized关键字，用来保证多线程访问情况下加上同步锁，将其它线程阻塞在同步锁外面，这样保证获取到是单个实例对象。
4、双重校验锁(DCL)
上面的单例模式在多线程调用getInstance()会产生性能问题。于是有了DCL单例模式。
DCL 是Double Check Lock的缩写。双重校验锁的意思是，只要保证在 检测null的操作和创建对象的操作时候，这两个操作能够原子地进行，那么单例就已经保证了。
public class SingletonDCL {
private static volatile SingletonDCL instance;
private SingletonDCL() {
}
public static SingletonDCL getInstance() {
if (instance == null) {
synchronized (SingletonDCL.class) {
if (instance == null) {
instance = new SingletonDCL();
}
}
}
return instance;
}
}
这种写法在getSingleton()方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字。
这种写法，在JDK5之前是不安全的：
- java的new不是原子的，具体在更细的层面还是有诸多步骤：
- 分配新对象的内存
- 调用类的构造器，初始化成员字段
- instance被赋为指向新的对象的引用。
说白了，JDK5之前不能保证有volatile修饰的对象构造内部是有序的。
- 线程A发现instance没有被实例化，它获得锁，然后去实例化该对象，JVM容许在没有完全实例化完成的时候，将实例的指针赋给这个instance变量，而此时instance==null就为false了，在初始化完成之前，线程B进入此方法，发现instance不为空，认为已经初始化完成了，于是便使用了这个尚未完全初始化的实例对象，可能引起其他的异常。
双重校验锁：既可以达到线程安全，也可以使性能不受很大的影响，换句话说在保证线程安全的前提下，既节省空间也节省了时间，集合了「饿汉式」和两种「懒汉式」的优点，取其精华，去其槽粕。
5、静态内部类
采用内部类，在这个类里面去创建实例对象，只要程序中不使用内部类JVM就不会去加载这个单例类，也就不会创建单例对象。从而实现「懒汉式」的延迟加载和线程安全。
public class SingletonInner {
private SingletonInner() {
}
public static SingletonInner getInstance() {
return SingletonInnerHolder.instance;
}
private static class SingletonInnerHolder{
private static final SingletonInner instance = new SingletonInner();
}
}
第一次加载Singleton类时并不会初始化sInstance，只有第一次调用getInstance方法时虚拟机加载SingletonHolder 并初始化sInstance ，这样不仅能确保线程安全也能保证Singleton类的唯一性，所以推荐使用静态内部类单例模式。
然而这还不是最简单的方式，《Effective Java》中作者推荐了一种更简洁方便的使用方式，就是使用「枚举」。
6、枚举
用枚举来实现单实例控制会更加简洁，而且无偿地提供了序列化机制，并由JVM从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。
public enum SingletonEnum {
INSTANCE;
}
7、使用容器
public class SingletonManager {
private static Map<String, Object> objMap = new HashMap<String,Object>();
private Singleton() {
}
public static void registerService(String key, Objectinstance) {
if (!objMap.containsKey(key) ) {
objMap.put(key, instance) ;
}
}
public static ObjectgetService(String key) {
return objMap.get(key) ;
}
}
这种事用SingletonManager 将多种单例类统一管理，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。
