七种单例模式

什么是设计模式？简单的理解就是前人留下来的一些经验总结而已，然后把这些经验起了个名字叫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 objMap = new HashMap();
　　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获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

参考文章：

【Java】设计模式：深入理解单例模式

1.5 七种单例模式